The start/stop exit routine runs either in a system address space
or the address space of the caller of CTRACE DEFINE. When a TRACE
CT operator command causes the start/stop exit to run, the routine
runs in a system address space. If a CTRACE DEFINE causes the start/stop
exit to run, either through a parmlib member specified on CTRACE DEFINE
or through a parmlib member with the PRESET option, the routine runs
in the caller's address space.
In either case, the routine might have to communicate with another
address space to make the trace options effective. The following methods
to accomplish this are described in this information:
- Use commonly addressable storage:
- Address space common areas
- SCOPE=ALL data spaces
- SCOPE=COMMON data spaces.
- Use a program call (PC) routine
- Schedule a service request block (SRB).
Using commonly addressable storage: If
the application doing the tracing does not have its own address space,
then it can maintain its trace options in commonly addressable storage.
The start/stop routine can copy the desired options from the CTSS
to the application-maintained trace control area in commonly addressable
storage.
Applications that do have their own address space can attach a
permanent task to process trace requests. When the start/stop exit
routine gets control, it could do the following:
- Obtain common storage to pass the CTSS information. (Consider
setting up a permanent area to hold the CTSS information.)
- Copy the CTSS information into this area.
- Post the task that processes the trace requests. (The ECB must
be in common storage.)
- Wait for the task to complete.
- Upon being posted with a return code, send the return code back
to component trace in register 15.
The task that processes the trace requests could do the following:
- Wait for a trace request.
- When posted, move the trace options to private storage.
- Parse any application-unique options if not already done in the
start/stop exit routine.
- Process the request to start, stop, or change the trace options.
- Post the start/stop exit with a return code.
- Loop back to wait for the next request.
Using a PC routine: The application
can implement a space-switching PC to get addressability to the correct
address space. In this case, the start/stop exit routine could do
the following:
- Set up a register pointing to the CTSS.
- Issue a PC to the PC routine responsible for processing trace
requests.
- Upon return, send the PC routine's return code back to component
trace.
The PC routine responsible for processing trace requests could
do the following:
- Use access register ASC mode to access the CTSS in the home address
space.
- Parse any application-specific options if not already done in
the start/stop exit routine.
- Process the request to start, stop, or change the trace options.
- Issue a program transfer (PT) or program return (PR) back to the
start/stop exit routine with a return code.
See z/OS MVS Programming: Extended Addressability Guide for further information about PC routines.
Scheduling an SRB: The application
can schedule an SRB to get addressability to the correct address space.
In this case, the start/stop exit routine could do the following:
- Obtain extended SQA storage for:
- An SRB
- A copy of the CTSS and related control areas
- An ECB.
- Initialize and schedule the SRB (SCHEDULE macro) to the application's
address space.
- Wait for the ECB to indicate that the SRB has completed.
- Upon being posted and receiving a return code, send the return
code back to component trace.
The SRB routine could do the following:
- Parse the application-unique options.
- Process the request to start, stop, or change the trace options.
- Post the start/stop routine and provide a return code.
See Using a service request block (SRB) for further information.