After logging onto CICS®, enter
the COD0 transaction ID to display
the COD0 main menu. Figure 22 shows the COD0 main menu
displayed under CICS/ESA, and CICS/MVS™.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Welcome to CICSPlex/SM Debugger. Commands available are: ALLOC Allocate storage, cache, cache list, queue, or eptr. ATTACH Starts a method running in MAS/CMAS. CALL Call a CICS transaction or program. CAPTURE Capture an EUI View to print. DUMP Call CODB transaction to display memory. EXEC Executes a method immediately from the debugger. EXIT Exit the debugger. LIST List methods, CP/SM tasks, and resources. POST Posts an ECB using MVS POST. PRINT Print a CP/SM data area to the JES Spooler. PURGE Delete a resource ALLOCated. START Starts a method running in CMAS. TRACE Set CICS component trace flags. TRACK Set CPSM trace flags based on calling structure. TRAP Set tracing flags for a single method. Enter HELP (command) for more help on commands.
To issue a COD0 debugging command, enter it in the CMD=>
input field. Commands can include one or more parameters, which must
be separated by one or more spaces. Commas and quoted strings are
not supported.
As in ISPF, PF key functions are prefixed to whatever is on the command line. The following PF keys are in effect when COD0 is running in a CICS/ESA, or CICS/MVS, environment:
You can enter the debugger commands
recursively from any screen in the COD0 transaction, effectively nesting
the commands and their output. However, under CICS/ESA, and CICS/MVS,
when the LIST and HELP commands are entered recursively, the new output
replaces the old. For example, if you issue the LIST START command
followed by the LIST TASK command, the LIST TASK output replaces the
LIST START output.
The following COD0 debugging commands can be used to modify
memory or some other aspect of CICSPlex® SM operation:
When you issue one of these commands, you receive a warning
and confirmation panel. You should proceed with the command only at
the request of customer support personnel.
The ALLOC command allocates a resource so that you can refer to it
by name in completing MALs. The resource can be a cache list, a
data queue, data space storage, or shared CICS storage.
The format of the ALLOC command is:
ALLOC /resname [optional parameters...]
where:
The optional parameters are:
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Allocate CACHE LIST Id of CACHE to create CACHE LIST: /@CACHE (Optional) Estimated number of elements: Element size: Estimated free space: (Optional) GENERIC if generic keys: (Optional) Hash Table Size: (Optional) Key Offset: 0 (Default 0) Key Size: Search method (BINSRCH/HASH): BINSRCH
Resources remain allocated across multiple COD0 transactions or between multiple COD0 transactions running concurrently in the same CICS system. In fact, all resources exist until you specifically purge them.
The ATTACH command starts a method running in the CICS systems
identified by the specified context and scope values.
The format of the ATTACH command is:
ATTACH method context scope
where:
For a list of valid responses to this command, see Running a method.
Unlike the START command, which merely starts a CICS transaction
within a CMAS, ATTACH crosses the boundary between a CMAS and
a local MAS. (These methods may run in the CMAS, a different address
space, or even a different processor in the CICSplex). To accomplish
this, ATTACH uses the logic of an end-user interface request, which runs under
its own TCB in the CMAS.
Figure 24 is an example of the display for a completed attached task that ran within a single CMAS or MAS.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Enter END to exit or ENTER to view results. Status for ATTACHed method XQCQ Methods status: Method completed. XLCI return description: OK Method's RESPONSE was: OK Method's REASON was: CONTEXT: CVMCTSO1 SCOPE: CSYSGRP1 REGION: CSYSGRP1 Unit of work SYSID: TEST USERID: DEVOPER TCB 00452160 Major Object: 00 Component Id: 73 The method executed in a single MAS so all information appears in the fields of the MAL.
Figure 25 is an example of the display for a completed attached task that either ran in multiple MASs, or ran multiple times in a CMAS.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Enter END to exit or ENTER to view results. Status for ATTACHed method XQCQ Methods status: Method completed. XLCI return description: OK Method's RESPONSE was: OK Method's REASON was: CONTEXT: CVMCTSO1 SCOPE: CSYSGRP1 REGION: CSYSGRP1 Unit of work SYSID: TEST USERID: DEVOPER TCB 00452160 Major Object: 00 Component Id: 74 The method executed in multiple MAS so a queue of OUT records was created. OUTQUE QUEUE ID: A4957FBD B3E11932 Records : 0000013 Record Length: 0000018
When you press Enter, each of the MALs that ran in each region is reconstructed and displayed individually, as shown in Figure 26.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE NEXT/PREV to browse CICS region MALS. END=Exit. MAL for CICS Region:CICSSY01 IN *ENM FUNCTION( CREQUE ) CHR DEBUG( ) PTR ECB( 00000000 ) *CMP MAJOR_OBJECT( KNL ) *ENM TYPE( WORK ) *SDT DELETE( TRUE ) OUT *ENM RESPONSE( OK ) *ENM REASON( ) *ETK QTOKEN( A4957FC53998FB31 )
Note also that the region the MAL ran in is shown on the header line for the display. You can use the NEXT (PF5) and PREV (PF4) keys to browse backwards and forwards between the regions. END (PF3) returns you to the attached task display.
The CALL command calls a CICS transaction or program with optional
parameters.
The format of the CALL command is one of the following:
CALL cicstran [optional parameters...]
CALL PROGRAM cicsprog [optional parameters...]
The parameters are passed as a TIOA area, so anything that can be entered at the transaction’s or program’s initial screen can be specified as an optional parameter. There is no validation of the optional parameters.
For transaction calls, the transaction ID is placed as the first field in the constructed TIOA (as it would be from the terminal). Make sure the transaction is defined as conversational. Pseudo- or nonconversational programs return immediately to COD0.
For program calls, you must enter the transaction ID as the first parameter, if the program you are calling expects this.
While the task is running, all the facilities of that CICS transaction or program are available to you. When you end the task, you return to COD0.
The CAPTURE command captures and prints all communications related to a CICSPlex SM end-user interface view being issued by a particular user. CAPTURE uses the CICS spool facility to write the data as an output file called Sxxxxxxx, where xxxxxxx is a numeric identifier.
The format of the CAPTURE command is one of the following:
CAPTURE viewname userid count
CAPTURE *MASMON montype count
where:
A count is taken from the time the view command is entered until the user enters another view command or END. Pressing Enter repeatedly to refresh the data or perform some action against the view does not change the count of the view command.
You can reissue the CAPTURE command with the same view name and user ID to update the count. A count of zero deletes the CAPTURE entry.
For example:
CAPTURE MONDEF USER39 3
captures the next three MONDEF view commands issued by USER39. All related MALs and queues are printed.
The DUMP command displays a scrollable dump of memory. Some
parameters of the DUMP command cause
the CICSPlex SM system-level debugging transaction, CODB, to be invoked.
If you alter the displayed memory, you must enter UPDATE (or press PF11) to record the change. If you alter memory but do not enter UPDATE, a message is displayed to remind you to enter UPDATE.
The format of the DUMP command is:
DUMP [parameters...]
where the parameters are:
Figure 27 shows an example XLWA display.
COMMAND==> XLWA COMP ID==> ADDR==> ALET==> 00000000 MSG==> 0012D0A8 00000000 08006EC5 E8E4D5E7 D2D5D3C3 E6C1C1C2 ..>EYUNXKNLCWAAB 0012D0B8 00000010 0D000200 00000000 00000000 00000000 ................ 0012D0C8 00000020 8001608B 0000000E 0000EE00 11F20000 ..-..........2.. 0012D0D8 00000030 0012D168 0000DE5C 113E8000 00000546 ..J....*........ 0012D0E8 00000040 116D4468 00040000 11F2EE00 00100000 ._.......2...... 0012D0F8 00000050 11F2EE00 FFFFFF6A 00000000 00000000 .2.....|........ 0012D108 00000060 00000000 D2D3D7C2 116D8EB0 116DB328 ....KLPB._..._.. 0012D118 00000070 116D7728 00CA812C 00000000 00000000 ._....a......... 0012D128 00000080 00000000 00000000 00000000 00346EC5 ..............>E 0012D138 00000090 E8E4E7C5 C5E8E4D9 E7C5D3E2 01030000 YUXEEYURXELS.... 0012D148 000000A0 00CC4008 0E1B9CE8 00CA8118 00CA812C .. ....Y..a...a. 0012D158 000000B0 00F69A00 009C9520 0000011C 00000001 .6....n......... 0012D168 000000C0 00000000 11F20000 11F21100 11F22200 .....2...2...2.. 0012D178 000000D0 11F23300 11F24400 11F25500 11F26600 .2...2...2...2.. 0012D188 000000E0 11F27700 11F28800 11F2AA00 11F29900 .2...2h..2...2r. 0012D198 000000F0 11F2BB00 11F2CC00 00000000 00000000 .2...2.......... 0012D1A8 00000100 11F2DD00 00000000 00000000 00000000 .2.............. 0012D1B8 00000110 00000000 00000000 00000000 00000000 ................ 0012D1C8 00000120 00000000 00000000 00000000 00000000 ................
The EXEC command executes a method directly from the COD0 debugging transaction.
The format of the EXEC command is:
EXEC method
where:
The formatted message argument list (MAL) for the method is displayed. For details about how to enter data from this display, see Displaying a MAL from COD0. For a list of valid responses to this command, see Running a method.
The EXIT command exits the COD0 debugging transaction. This command has no parameters.
You can use this command to exit the debugging transaction from any screen. A closing message is displayed; you can then clear the CICS screen and enter another transaction.
All allocated resources and started or attached tasks are recorded in a temporary storage record. The next time you enter COD0, all allocated resources are still available and all started or attached tasks can be displayed using the LIST START command.
The HELP command displays help text for COD0 commands.
The format of the HELP command is:
HELP [cmdname | COMPID]
where:
If you issue the HELP command without parameters, the initial help panel, which lists all COD0 commands, is displayed.
The LIST command lists running CICSPlex SM tasks, the status of started and attached tasks, and the allocated resources available to you.
The format of the LIST command is:
LIST [parameters...]
where the parameters are:
Lists all the resources that have been allocated by the ALLOC command. Figure 29 shows an example of the LIST ALLOC display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Select P=Purge resource D=Dump resource S Type Name Token Length MajObj _ CACHE /@CACHE 01FF0004 000026E0 _ QUE /QUE A44C5E58 27257332 MAS _ CLIST /C 000026E0 00106DF8 256 _ STG /STG 00000000 04289000 4096 _ EPTR /E 01FF0005 00001B00 2048
The fields on this display are:
You can enter the following in the selection field:
LIST ATCB lists the API task control blocks. These control blocks are used when a CICSPlex SM API operation is in progress.
COD1 CICSPlex/SM Debugger APPLID=IYEGZGC0 CMD=> Scroll=> PAGE D=Dump ATCB C=Dump CMDDesc T=Task END=Exit. S ATCB Status Task# Cmd Origin DispTime APITime _ 164B82B0 Active * 6337 GET_ IYEGZGW0/7186 00:00.00 00:32.93 _ 164B78D0 Avail * 6344 _ 164B5ED0 Free _ 164B58D0 Free _ 1649EED0 Free _ 1649ECB0 Free Total API Commands: 114,842
The fields on this display are:
For non-CICS based requests, Origin is the MVS jobname of the address space making the CICSPlex SM API request being processed.
This field is displayed only when Status=Active.
This field is displayed only when Status=Active.
This field is displayed only when Status=Active.
The Total API Commands line displays the count of CICSPlex SM API commands that have been processed by all ATCBs.
Lists the data caches in use by a local MAS. Figure 30 shows an example of the LIST CACHE display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE D=Dump lowest ALET:X'1000' S Cache ALET Low Ofs High Ofs HWM Allocated (Hex) _ DMDSCWW1 01FF001B 00000000 00801000 4,229,376 (00408900) _ WLM1CWW1 01FF0007 00000000 00400000 3,543,040 (00361000) _ RTA1CWW1 01010042 00000000 00400000 524,288 (00080000) _ MON1CWW1 01010041 00000000 00400000 524,288 (00080000) _ TOP1CWW1 01FF0006 00000000 00400000 655,360 (000A0000) _ COM1CWW1 01010040 00000000 00400000 1,691,648 (0019D000) _ MAS1CWW1 01FF0008 00000000 00400000 933,888 (000E4000) _ DAT1CWW1 0101003F 00000000 00400000 1,527,808 (00175000) _ QUE1CWW1 01FF0005 00000000 00400000 1,048,576 (00100000)
The fields on this display are:
Figure 31 shows an example of the LIST CACHE display.
DBG0 CICSPlex/SM Debugger Applid:CICSWIN CMD=> Scroll=> PAGE _ Token ElemLen Keylen Keyoff Records MaxRecs FreeRec Storage _ 00000001-0123FA2C 300 5 0 3 10 1 760
The fields on this display are:
You can enter the following in the selection field:
Lists all ISPF end-user interface views currently being captured. Figure 32 shows an example of the LIST CAPTURE display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Enter END to exit. ViewName User ID Count Debug AltDebug Desc FILES CVMCW2 2 OT NT File Summary LOCFILE CVMCW2 2 O8 N8 Local Files
The fields on the LIST CAPTURE display are:
Lists the data cache lists in use by the CMAS. Figure 33 shows an example of the LIST CLIST display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE D=Dump the Cache List S Token DataAlet DataStrt DataEnd EleSz ElemCnt Key Len T S Alt _ 01FF001B00408990 01FF0007 00071000 00073C00 20 0 0 16 S B YES _ 01FF001B00408830 01FF0007 0016E000 00177E5C 72 0 0 16 S B YES _ 01FF001B004086D0 01FF0007 00165000 0016DCC4 64 0 0 16 S B YES
The fields on this display are:
Lists the two communication MAL queues: one for methods executing via the CMAS, and the other for methods routed to a MAS. Figure 34 shows an example of the LIST COMM display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE S CSFM MAL XLTD Type Node Type Target SysId Sequence Response List for: MAL List _ TSQO 001ABC00 00E1E300 Outbound Local MAS CMAS1AB CAB1 00000012
The fields on this display are:
Lists all methods within the specified component. Figure 35 shows an example of the LIST METH display typical
of those produced under CICS/ESA, and CICS/MVS.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE L=Dump Load Pt END=Exit. S Typ Meth Function Fmt Tran LoadPt ServLevl Assembly Date Status _ PUB CWAA ADDTMED 01 077130C0 CPSM210 05/19/98 06.05 ACTIVE _ PUB CWAB BROTMED 02 07713348 CPSM210 05/19/98 06.05 ACTIVE _ PUB CWAD DELTMED 03 077138F0 CPSM210 05/19/98 06.05 ACTIVE _ PUB CWAU UPDTMED 04 07713B40 CPSM210 05/19/98 06.05 ACTIVE
The fields on this display are:
Lists the status of all methods you’ve started or attached. Figure 36 shows an example of the LIST START display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Select P=Purge V=View MAL D=Dump MAL END=Cont. S Type Meth Task N Status _ START XQCQ 828 Completed, RESPONSE:OK _ START NSCR 844 Completed, RESPONSE:OK _ START NQPG 860 Completed, RESPONSE:EXCEPTION(ABEND)
The fields on this display are:
You can enter the following in the selection field:
Lists the server-client control blocks. These control blocks are used by CICSPlex SM communications and the end-user interface to request work in a CMAS. Figure 37 shows an example of the LIST STCB display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE V=View MAL D=Dump MAL S=Dump STCB X=Dump XLSP S Address Status Last Usr From Error CSFM Context Scope OutQue _ 060C9BA0 Avail COM 0 TSPV PLEX2C1 PLEX2C1 NO _ 060C97C0 Avail COM 0 TSCV NO _ 060C93E0 Avail COM 0 CSAC NO
The fields on this display are:
Displays all CICSPlex SM tasks and the methods being called
within them. Figure 38 shows an example of the LIST TASK
display typical of those produced under CICS/ESA, and CICS/MVS.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE DUMP L=Loadpt P=oPb O=Ossb S=Stack M=Mal B=modB E=moEb V=MAL END=Cont. S Task # METH Load-pt oPb Ossb Stack Mal modB moEB _ 27 XLOP 00000000 00489FA8 00489FF0 0048A014 04283580 000CF820 00000000 _ 27 DBG1 8A5B9690 00489FA8 00489FF0 0048A118 0A4602E4 000CF820 00000000 _ 20 XLEV 00000000 00494FA8 00494FF0 00495014 04273580 000CF820 00000000 _ 23 XLOP 00000000 00491FA8 00491FF0 00492014 04277580 000CF820 00000000 _ 23 TIST 0A55C430 00491FA8 00491FF0 00492118 00490FD4 000D7D00 04274160 _ 23 XSWC 0A514018 00491FA8 00491FF0 004925A0 0049244C 000D29F4 000DE0B0 _ 24 XLOP 00000000 0048DFA8 0048DFF0 0048E014 0427F580 000CF820 00000000 _ 24 RSWT 0A574728 0048DFA8 0048DFF0 0048E118 0048CFD4 000DAED4 042744D0 _ 24 XSWC 0A514018 0048DFA8 0048DFF0 0048E4D8 0048E3BC 000D29F4 000DE0B0
This display shows one line per method with a space between CICSPlex SM tasks. The fields on this display are:
You can enter the following in the selection field:
During a LIST TASK command the entire chain of CICSPlex SM blocks that apply to a task are followed. The eyecatcher for each of the blocks is checked, in addition to the forward and backward methods within stacks and possible recursive chains. If any errors are found, you may see one of the following error messages after the last valid entry:
Stack chain broken at AAAAAAAA
This error indicates that the previous method’s ID within a stack chain does not match the previous method’s ID. This may be the case if code within the method overlays the stack header. AAAAAAAA is the address of the invalid stack frame.
OPB chain error at AAAAAAAA
Object process blocks are created for each CICS CICSPlex SM task. They are chained together for the component ID of the first method in the chain. If this chain points back to itself (a recursive chain), this message appears. AAAAAAAA is the address of the OPB that was next after the previously displayed OPB.
Eyecatcher failed for CSFM at AAAAAAAA
If an eyecatcher of a control block that is visited during a LIST TASK is incorrect, this message appears. AAAAAAAA is the address of the control block in question and CSFM is its name.
DFHEIBLK block invalid at AAAAAAAA, OPB at AAAAAAAA
invalid
The task’s object process block is really the CICS DFHEISTG area. In this area is a pointer to the task’s CICS EIB block, which is checked during LIST TASK commands.
Lists all ISPF end-user interface views that can be captured. You can qualify the list by using the mask option to specify a generic key. Figure 39 shows an example of the LIST VIEWS display. The mask option was used to display only those views that begin with the letter A.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Enter END to exit. View DistName Type Class Name Desc ACTNDEF EYUZEGP0 TRTAA ActDef Action Definitions ADMANLS EYUZEAZ4 TMENU3 ViewTable Real Time Analysis Admin Views ADMCONFG EYUZEAZ1 TMENU3 ViewTable CMAS Configuration Admin Views ADMIN EYUZE$MM TMENU2 ViewTable ============================ ADMMON EYUZEAZ2 TMENU3 ViewTable Monitor Admin Views ADMTOPOL EYUZEAZ5 TMENU3 ViewTable Topology Admin Views ADMWRKLD EYUZEAZ3 TMENU3 ViewTable Workload Manager Admin Views AIMODEL EYUZEK50 TOPERATE CicsAiModel Auto Install Models AIMODELS EYUZEK5S TOPERATE CicsAiModel Auto Install Model Summary ANALYSIS EYUZEAZR TMENU1 ViewTable Real Time Analysis Views
The fields on this display are:
The POST command posts an ECB using the MVS POST command.
The format of the POST command is:
POST address
where address is a 1- to 8-character hexadecimal number that is the address at which the ECB resides.
No check is made to see whether an ECB exists at this address or whether it is already posted; an MVS POST command is simply issued.
The PRINT command prints a CICSPlex SM data area. PRINT uses the CICS spool facility to write the data area as an output file called Sxxxxxxx, where xxxxxxx is a numeric identifier.
The format of the PRINT command is:
PRINT [parameters...]
where the parameters are:
The PURGE command purges an allocated resource.
The format of the PURGE command is:
PURGE /resname
where:
The START command starts a method running within the CMAS.
The format of the START command is:
START method [termid]
where:
The message argument list (MAL) of the method is displayed. For details about how to enter data from this display, see Displaying a MAL from COD0. For a list of valid responses to this command, see Running a method.
Figure 40 shows an example of the START display.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Overtype fields and press ENTER to edit, END to proceed, CANCEL to abort. Dn IN ENM FUNCTION( SETCRGN ) CHR DEBUG( ) BIN SYSTEM_AKP( ) BIN SYSTEM_AMAXTASKS( ) BIN SYSTEM_CUSHION( ) CHR SYSTEM_DTRPROGRAM( ) BIN SYSTEM_ECUSHION( ) BIN SYSTEM_MAXTASKS( ) BIN SYSTEM_MROBATCH( ) BIN SYSTEM_PRTYAGING( ) BIN SYSTEM_RUNAWAY( ) BIN SYSTEM_SCANDELAY( ) BIN SYSTEM_SYSDUMP( ) BIN SYSTEM_TIME( ) BIN TRACEDEST_AUXSTATUS( ) BIN TRACEDEST_GTFSTATUS( ) BIN TRACEDEST_INTSTATUS( ) BIN TRACEDEST_SWITCHSTAT( ) BIN TRACEDEST_SWITCHACT( )
The START command starts a CICS task that eventually executes method DBG2. This method is created dynamically by COD0 in every component.
The TRACE command can be used to:
The format of the TRACE command is:
TRACE [parameters...]
where the parameters are :
Changes made to CICS and CICSPlex SM trace settings from the COD0 debugging transaction remain in effect after you exit the transaction.
The TRACK command sets CICSPlex SM trace flags based on the calling structure.
The format of the TRACK command is:
TRACK target relation calling flags id
where the parameters are:
For example:
TRACK XD* STAK CI* SPEC UTOM
activates all trace flags for any data repository method that is called directly or indirectly from any communication initialization method, when the task is handling an EUI request from ID TOM.
The TRAP command sets trace flags on for a specific CICSPlex SM method.
The format of the TRAP command is:
TRAP method [1|2|ALL|OFF]
where:
When entering into a MAL formatted by the COD0 debugging transaction, all input is validated for both physical and logical properties.
When viewing or updating a MAL, either from a START, ATTACH, or EXEC command, or from LIST output, the format of the display is as shown in Figure 41.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE Fields with "->" required. IN *ENM FUNCTION( TEST ) CHR DEBUG( ) -> FLG FLAG_VALUES( ) OUT *ENM RESPONSE( ) *ENM REASON( )
As shown in Figure 41, IN and OUT eyecatchers separate the major sections of the MAL. Each field name in the IN and OUT sections can be preceded by three other indicators:
The three-character code that precedes a field determines what can be entered in the field and the kind of data that is displayed. Table 5 shows the input allowed for each field type.
Type | Format | Input allowed |
---|---|---|
BIN | BIN(n) | Hexadecimal number |
BLK | BLOCK | Hexadecimal number for address or decimal number for length |
BUF | BUFFER | Hexadecimal number for address, decimal number for length, or resource name (/resname) |
CHR | CHAR(n) | Any character |
CMP | COMPID | Component ID or '?' for a list |
DEC | DEC(n) | Decimal number |
EBK | EBLOCK | Hexadecimal number for ALET and OFFSET, decimal number for length, or resource name (/resname) |
ENM | (names) | Names defined in format or '?' for list |
EPT | EPTR | Hexadecimal number for ALET and OFFSET or resource name (/resname) |
ETK | ETOKEN | Hexadecimal number or resource name (/resname) |
FLG | FLAG | Hexadecimal representation of a flag or '?' for a list |
LST | LIST | Hexadecimal number for address, decimal number for length, or resource name (/resname) |
MPL | MAL | Hexadecimal number or resource name (/resname) |
PTR | PTR | Hexadecimal number or resource name (/resname) |
RES | RESTYPE | Resource name (/resname) or '?' for a list |
SDT | SDT | TRUE or FALSE |
STR | STRING(n) | Any character |
TIM | TIMESTAMP | Hexadecimal number |
TKN | TOKEN | Hexadecimal number or resource name (/resname) |
In a MAL display, input is edited and output is formatted according to the following rules:
You can enter decimal characters instead of hexadecimal by preceding the value with a backslash, as in \1234. The decimal number is internally converted to hexadecimal.
You can enter hexadecimal characters instead of decimal by preceding the value with a backslash, as in \ABCD. The hexadecimal number is internally converted to decimal.
For a field type of RES, you can use the HELP command to display a list of known resource types, such as HELP RESOP or HELP CVDA.
Many fields in a MAL consist of multiple subfields, which are divided into multiple input fields and validated separately. Each field is preceded by the suffix of the subfield. For example, the EPT field is made up of the ALET and OFFSET subfields, and looks like this when the MAL is displayed:
EPT YOUR_MAL_FIELD_NAME(A= alet O= offset)
The subfields associated with each field type are as follows:
You can use the names of allocated resources (such as cache lists, data queues, data space storage, or CICS storage) in the input fields of a MAL. (For information on allocating resources, see ALLOC (allocating a resource).)
If the field contains subfields, as described in Subfields, you need enter only the resource name in the first field; the COD0 debugging transaction determines the other field types and fills them in for you.
For example, you could use the ALLOC command to allocate 4K of data space storage to the resource called /workara, as shown in Figure 42.
COD0 CICSPlex/SM Debugger CMD=> ALLOC /workara EPTR 4096 Scroll=> PAGE IN
Figure 43 shows the allocated resource, /workara, being used as input to a MAL.
COD0 CICSPlex/SM Debugger CMD=> Scroll=> PAGE IN *ENM FUNCTION( TEST ) CHR DEBUG( ) EPT OUT_ADDR(A= /workara O= )
The COD0 debugging transaction places the ALET of the allocated storage area into the A= field; the offset is automatically entered in the O= field.
From a formatted MAL display you can enter the following commands:
If you return to the COD0 main menu while a method is running, a LIST START command is automatically issued.
You can use the LIST or LIST START command to check the progress of the started or attached method. When you END the LIST display control returns to the formatted MAL display.