CICS Problem Determination Guide
CICS Problem Determination Guide
GC33-5719-00
CICS® Transaction Server for z/OS™
GC33-5719-00
Note!
Before using this information and the product it supports, be sure to read the general information under “Notices” on
page 365.
Contents v
The dump you got did not seem to relate to your CICS region . . . . . . 173
You did not get a dump when an abend occurred. . . . . . . . . . . 173
Some dump IDs were missing from the sequence of dumps . . . . . . . 175
You did not get the correct data formatted from a CICS system dump . . . 176
Wrong data has been displayed on a terminal . . . . . . . . . . . . . 176
The preliminary information you need to get. . . . . . . . . . . . . 177
Specific types of incorrect output, and their possible causes . . . . . . . 177
Tools for debugging terminal output in a VTAM environment . . . . . . . 182
Incorrect data is present on a VSAM data set . . . . . . . . . . . . . 183
An application did not work as expected . . . . . . . . . . . . . . . 183
General points for you to consider . . . . . . . . . . . . . . . . 183
Your transaction produced no output at all . . . . . . . . . . . . . . 184
Are there any messages explaining why there is no output? . . . . . . . 184
Can you use the terminal where the transaction should have started? . . . 184
No output—what to do if the task is still in the system . . . . . . . . . 185
No output—what to do if the task is not in the system . . . . . . . . . 185
Did the task run? Techniques for all tasks . . . . . . . . . . . . . 185
Investigating tasks initiated by ATI . . . . . . . . . . . . . . . . 188
Your transaction produced some output, but it was wrong. . . . . . . . . 190
The origins of corrupted data . . . . . . . . . . . . . . . . . . 190
Were records in the file incorrect or missing? . . . . . . . . . . . . 190
Was the data mapped correctly into the program? . . . . . . . . . . 191
Is the data being corrupted by bad programming logic? . . . . . . . . 191
Is the data being mapped incorrectly to the terminal? . . . . . . . . . 192
Chapter 11. Dealing with external CICS interface (EXCI) problems . . . . 203
Contents vii
Chapter 17. The global trap/trace exit . . . . . . . . . . . . . . . 297
Establishing the exit . . . . . . . . . . . . . . . . . . . . . . 297
Information passed to the exit . . . . . . . . . . . . . . . . . . . 297
Actions the exit can take . . . . . . . . . . . . . . . . . . . . . 298
Program check handling . . . . . . . . . . . . . . . . . . . . . 299
Coding the exit . . . . . . . . . . . . . . . . . . . . . . . . 299
Bibliography . . . . . . . . . . . . . . . . . . . . . . . . . 339
CICS Transaction Server for z/OS . . . . . . . . . . . . . . . . . 339
CICS books for CICS Transaction Server for z/OS . . . . . . . . . . 339
CICSPlex SM books for CICS Transaction Server for z/OS . . . . . . . 340
Other CICS books . . . . . . . . . . . . . . . . . . . . . . 340
Determining if a publication is current . . . . . . . . . . . . . . . . 340
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Notices . . . . . . . . . . . . . . . . . . . . . . . . . . . 365
Contents ix
x CICS Transaction Server: CICS Problem Determination Guide
Preface
What this book is about
This book is about methods of determining the causes of problems in a system that
uses CICS®. It contains information about resolving CICS application and system
problems, dealing with the IBM® Support Center, and handling authorized program
analysis reports (APARs).
In general, this book does not describe methods of problem determination for the
CICS Front End Programming Interface. This information is included in the CICS
Front End Programming Interface User’s Guide.
Note: For problem determination of the ONC/RPC feature, see the CICS External
Interfaces Guide.
Refer to Table 1 to find the section of the book that you need to read.
Table 1. Road map for the CICS Problem Determination Guide
If you want to... Refer to...
Go through some preliminary checks “Chapter 1. Introduction to problem determination” on
page 3
Classify the problem according to its symptoms “Chapter 2. Classifying the problem” on page 7
Look for information to help you diagnose and resolve the “Chapter 3. Sources of information” on page 17
problem
Resolve transaction abnormal terminations. “Chapter 4. Dealing with transaction abends” on page 29
Resolve system abnormal terminations. “Chapter 5. Dealing with CICS system abends” on
page 43
Decide whether the problem is caused by a wait, a loop, “Distinguishing between waits, loops, and poor
or a performance problem. performance” on page 12
Resolve problems caused by waits. “Chapter 6. Dealing with waits” on page 55
Resolve problems caused by loops. “Chapter 7. Dealing with loops” on page 149
Resolve problems caused by performance problems. “Chapter 8. Dealing with performance problems” on
page 159
Know what to do if you don’t get the output you expected. “Chapter 9. Dealing with incorrect output” on page 169
Resolve problems caused by storage violations. “Chapter 10. Dealing with storage violations” on page 193
“MVS™” is used for the operating system, which can be either an element of
OS/390, or MVS/Enterprise System Architecture System Product (MVS/ESA™
SP™).
Throughout this book, the term APPC is used to mean LUTYPE6.2. For example,
APPC session is used instead of LUTYPE6.2 session.
| For problem determination guidance associated with Java and CICS EJB, see Java
| Applications in CICS.
Part 1 contains:
Usually, you start with a symptom, or set of symptoms, and trace them back to their
cause. This book describes tools and techniques you can use to find the cause of a
problem and suggests action for solving the problem.
Sometimes, you cannot solve the problem yourself if, for example, it is caused by
limitations in the hardware or software you are using. If the cause of the problem is
CICS code, you need to contact IBM, as described in “Part 4. Working with IBM to
solve your problem” on page 301.
As you go through the questions, make a note of anything that might be relevant to
the problem. Even if the observations you record do not at first suggest a cause,
they could be useful to you later if you need to carry out systematic problem
determination.
1. Has the CICS system run successfully before?
If the CICS system has not run successfully before, it is possible that you have
not yet set it up correctly. You need to read other books in the CICS library for
guidance on doing this.
If you are currently migrating to CICS Transaction Server for z/OS, Version 2
Release 1, ensure that you are aware of all the changes that have been made
for this release. For details of these, see the CICS Transaction Server for z/OS
Migration Guide.
2. Are there any messages explaining the failure?
If a transaction abends, and the task terminates abnormally, CICS sends a
message reporting the fact to the CSMT log (or your site replacement). If you
find a message there, it might immediately suggest a reason for the failure.
Were there any unusual messages associated with CICS start up, or while the
system was running before the error occurred? These might indicate some
system problem that prevented your transaction from running successfully.
If you see any messages that you do not understand, you can use the CICS
messages transaction, CMAC, for online message information. If you do not
have access to a CICS system to run the CMAC transaction, look in the CICS
Messages and Codes manual for an explanation and, perhaps, a suggested
course of action that you can take to resolve the problem.
3. Can you reproduce the error?
a. Can you identify any application that is always in the system when the
problem occurs?
v Check for application coding errors.
v Check that you have defined sufficient resource for the application, such
as VSAM file strings. Typically, if you had not defined sufficient resources,
you would find that the problem is related to the number of users of the
application.
Hardware
a. Have you changed your hardware?
Software
a. Have you changed your software?
b. If you have installed a new or modified application, check for error
messages in the output from the following:
Administration
a. Have you changed your initialization procedure, for example by JCL, CICS
system initialization or override parameters, or VTAM CONFIG/LIST?
b. Has CICS generated any error messages during initialization?
c. Have you installed any resource definitions defined using CEDA?
If the definitions were made but not installed when CICS was last
terminated, they might not have been preserved over the termination and
subsequent start up. In general, changes made to the CSD but not installed
are not visible when the CICS system is warm started. However, if the
change was in a group in the GRPLIST specified on a cold start, it is
effectively installed during startup. (Changes which have been installed are
not visible after a cold start unless they were made to a group in the
GRPLIST.)
If START=AUTO was specified in the system initialization table, or as an
override, you need to examine the job log to find out how the CICS system
last came up.
For detailed guidance about the ways in which resources can be defined
and installed, see the CICS Resource Definition Guide.
7. Are specific parts of the network affected by the problem?
a. Can you identify specific parts of the network that the problem affects? If
you can, look for any explanatory message from the access method. Even if
no message has been sent to the console, you might find one in the CSNE
log.
b. Have you made any network-related changes?
c. If the problem affects a single terminal, are your terminal definitions correct?
Consider both the TERMINAL definition, and the TYPETERM definition it
uses.
d. If the problem affects a number of terminals, can you identify a factor that is
common to all of them? For example:
v Do they use the same TYPETERM definition? If so, it is likely that there is
an error in that TYPETERM definition.
v Is the whole network affected? If so, CICS has probably stalled. See
“What to do if CICS has stalled” on page 144 for advice about dealing
with CICS system stalls.
8. Has the application run successfully before?
a. Have any changes been made to the application since it last ran
successfully?
Examine the new or modified part of the application.
b. Have you used RDO to create or alter a transaction, program, or mapset?
You must install these definitions before the resources are available to the
running CICS region.
c. If you changed any maps, have you created both a new phase
(TYPE=MAP) and a new DSECT (TYPE=DSECT), and then recompiled
every program using the new DSECT? Use the CEMT commands:
CEMT SET PROGRAM(mapset) NEWCOPY
CEMT SET PROGRAM(all programs) NEWCOPY
What to do next
Perhaps the preliminary checks have enabled you to find the cause of the problem.
If so, you should now be able to resolve it, possibly with the help of other books in
the CICS library and in the libraries of other licensed programs.
If you have not yet found the cause, you must start to look at the problem in greater
detail. Begin by finding the best category for the problem, using the approach
described in “Chapter 2. Classifying the problem” on page 7.
IBM Support Center staff have found that classifying the problem first is a good
approach to problem determination.
If you have the IBM INFORMATION/ACCESS licensed program, 5665-266, you can
look on the RETAIN database yourself. Each of the problems there has a
classification type.
All but the last of these, MESSAGE, are considered in this book. If you receive a
CICS error message, you can use the CICS message transaction, CMAC, for online
message information. If you do not have access to a running CICS system, look in
the CICS Messages and Codes manual for an explanation. If you get a message
from another IBM program, or from the operating system, you need to look in the
messages and codes book from the appropriate library for an explanation of what
that message means.
The CICS Messages and Codes manual might give you enough information to
solve the problem quickly, or it might redirect you to this manual for further
guidance. If you are unable to deal with the message, you may eventually need to
contact the IBM Support Center for help.
One type of problem that might give rise to a number of symptoms, usually
ill-defined, is that of poor application design. Checking the design of an application
is beyond the scope of this book, but one instance is described in “Poor application
design” on page 15, where you will find there an example of how bad design can
give rise to an application with poor usability.
Whereas XRF, EXCI, and MRO errors can easily be classified in a straightforward
way, confirming that you have a storage violation can be difficult. Unless you get a
CICS message stating explicitly that you have a storage violation, you could get
almost any symptom, depending on what has been overlaid. You might, therefore,
classify it initially as one of the RETAIN symptom types described in “Symptom
keywords as a basis for classifying problems” on page 7.
The symptoms might enable you to classify the problem correctly at once, but
sometimes classification is not so straightforward. You may need to consider the
evidence carefully before making your decision. You might need to make a “best
guess”, and then be prepared to reconsider later on the basis of further evidence.
Look for the section heading that most nearly describes the symptoms you have,
and then follow the advice given there.
Consider, too, the possibility that CICS might still be running, but only slowly. Be
certain that there is no activity at all before carrying out the checks in this section. If
CICS is running slowly, you probably have a performance problem. If so, read
“CICS is running slowly” on page 9 to confirm this before going on to “Chapter 8.
Dealing with performance problems” on page 159 for advice about what to do next.
If CICS has stopped running, look for any message that might explain the situation.
The message might appear in either of the following places:
v The MVS console. Look for any message saying that the CICS job has
abnormally terminated. If you find one, it means that a CICS system abend has
occurred and that CICS is no longer running. In such a case, you need to
examine the CSMT log (see below) to see which abend message has been
written there.
Here are two examples of messages that might accompany CICS system abends,
and which you would find on the CSMT log:
If you get either of these messages, or any others for which the system action is to
terminate CICS, turn to “Chapter 5. Dealing with CICS system abends” on page 43
for advice on what to do next.
If you can find no message saying that CICS has terminated, it is likely that the
CICS system is in a wait state, or that some program is in a tight loop and not
returning control to CICS. These two possibilities are dealt with in “Chapter 6.
Dealing with waits” on page 55 and “Chapter 7. Dealing with loops” on page 149,
respectively.
If you find that performance degradation is not dependent on system loading, but
happens sometimes when the system is lightly loaded, a poorly designed
transaction could be the cause. You might classify the problem initially as “poor
performance”, but be prepared to reconsider your classification later.
The following are some individual symptoms that could contribute to your perception
that CICS is running slowly:
v Tasks take a long time to start running.
v Some low priority tasks will not run at all.
v Tasks start running, but take a long time to complete.
v Some tasks start running, but do not complete.
v No output is obtained.
v Terminal activity is reduced, or has ceased.
Some of these symptoms do not, in isolation, necessarily mean that you have got a
performance problem. They could indicate that some task is in a loop, or is waiting
on a resource that is not available. Only you can judge whether what you see
should be classified as “poor performance”, in the light of all the evidence you have.
For guidance about using these tools and techniques, and advice about
performance and system tuning in general, see the CICS Performance Guide.
You can find guidance about identifying specific performance bottlenecks in your
CICS system in “Chapter 8. Dealing with performance problems” on page 159.
Note: Do not overlook the possibility that the task might simply be doing
unnecessary work that does not change the final result—for example,
starting a skip sequential browse with large gaps between the keys, or failing
to finish one because it is holding on to resources.
First, make sure that the task is still in the system. Use CEMT INQ TASK to check
its status, and make sure that it has not simply ended without writing back to the
terminal.
If the terminal has a display unit, check to see whether a special symbol has been
displayed in the operator information area that could explain the fault. If the
operator information area is clear, next check to see that no message has been
sent to any of the transient data destinations used for error messages, for example:
v CDBC, the destination for DBCTL related messages
v CSMT, the destination for terminal error and abend messages
For details of the destinations used by CICS, see the CICS System Definition
Guide. If you can find no explanation for the problem, the fault is probably
associated with the task running at the terminal. These are the possibilities:
v The task is in a wait state.
v The task is in a loop.
v There is a performance problem.
Use the CMAC transaction or look in the CICS Messages and Codes manual for an
explanation of the message, and, perhaps, advice about what you should do to
solve the problem. If the code is not there, or the explanation or advice given is not
sufficient for you to solve the problem, turn to “Chapter 4. Dealing with transaction
abends” on page 29.
If you have received an unexpected message, and its meaning is not at first clear,
use the CMAC transaction or look in the CICS Messages and Codes manual for an
explanation. It might suggest a simple response that you can make to the message,
or it might redirect you to this manual for further guidance.
These are the types of incorrect output that are dealt with in this manual:
v Incorrect trace or dump data:
– Wrong destination
– Wrong type of data captured
– Correct type of data captured, but the data values were unexpected
v Wrong data displayed on the terminal.
You can find advice about investigating the cause of any of these types of incorrect
output in “Chapter 9. Dealing with incorrect output” on page 169.
In many cases, storage violations go undetected by CICS, and you only find out
that they have occurred when something else goes wrong as a result of the overlay.
You could, for example, get a program check because code or data has been
overlaid. You might suspect some other type of problem at first, and only after
starting your investigation find that a storage violation has occurred.
You can avoid many storage violations by enabling transaction isolation, storage
protection, and command protection.
This section gives you guidance about choosing the best classification. When you
have decided on that, read the appropriate section later in thismanual for further
advice. However, note that in some cases your initial classification could be wrong,
and you then need to reappraise the problem.
Waits
For the purpose of problem determination, a wait state is regarded as a state in
which the execution of a task has been suspended. That is, the task has started to
run, but it has been suspended without completing and has subsequently failed to
resume.
The task might typically be waiting for a resource that is unavailable, or it might be
waiting for an ECB to be posted. A wait might affect just a single task, or a group of
tasks that may be related in some way. If none of the tasks in a CICS region is
running, CICS is in a wait state. The way to handle that situation is dealt with in
“What to do if CICS has stalled” on page 144.
If you are authorized to use the CEMT transaction, you can find out which user
tasks or CICS-supplied transactions are currently suspended in a running CICS
system using CEMT INQ TASK. Use the transaction several times, perhaps
You can use EXEC CICS INQUIRE TASK or EXEC CICS INQUIRE TASK LIST as
alternatives to the CEMT transaction. You can execute these commands under
CECI, or in a user program.
Use INQUIRE TASK LIST to find the task numbers of all SUSPENDED, READY,
and RUNNING user tasks. If you use this command repeatedly, you can see which
tasks stay suspended. You may also be able to find some relationship between
several suspended tasks, perhaps indicating the cause of the wait.
If it seems fairly certain that your problem is correctly classified as a wait, and the
cause is not yet apparent, turn to “Chapter 6. Dealing with waits” on page 55 for
guidance about solving the problem.
However, you should allow for the possibility that a task may stay suspended
because of an underlying performance problem, or because some other task may
be looping.
If you can find no evidence that a task is waiting for a specific resource, you should
not regard this as a wait problem. Consider instead whether it is a loop or a
performance problem.
Loops
A loop is the repeated execution of some code. If you have not planned the loop, or
if you have designed it into your application but for some reason it fails to terminate,
you get a set of symptoms that vary depending on what the code is doing. In some
cases, a loop may at first be diagnosed as a wait or a performance problem,
because the looping task competes for system resources with other tasks that are
not involved in the loop.
Some loops can be made to give some sort of repetitive output. Waits and
performance problems never give repetitive output. If the loop produces no output,
a repeating pattern can sometimes be obtained by using trace. A procedure for
doing this is described in “Chapter 7. Dealing with loops” on page 149.
If you are able to use the CEMT transaction, try issuing CEMT INQ TASK
repeatedly. If the same transaction is shown to be running each time, this is a
further indication that the task is looping. However, note that the CEMT transaction
is always running when you use it to inquire on tasks.
If different transactions are seen to be running, this could still indicate a loop, but
one that involves more than just a single transaction.
If you are unable to use the CEMT transaction, it may be because a task is looping
and not allowing CICS to regain control. A procedure for investigating this type of
situation is described in “What to do if CICS has stalled” on page 144.
Consider the evidence you have so far. Does it indicate a loop? If so, turn to
“Chapter 7. Dealing with loops” on page 149, where there are procedures for
defining the limits of the loop.
Poor performance
A performance problem is considered to be one in which system performance is
perceptibly degraded, either because tasks fail to start running at all, or because
they take a long time to complete once they have started.
In extreme cases, some low-priority tasks may be attached but then fail to be
dispatched, or some tasks may be suspended and fail to resume. The problem
might then initially be regarded as a wait.
If you get many messages telling you that CICS is under stress, this can indicate
that either the system is operating near its maximum capacity, or a task in error has
used up a large amount of storage—possibly because it is looping.
You see one of the following messages when CICS is under stress in one of the
DSAs:
This book does not deal with the principles of application design, or how to check
whether poor design is responsible for a problem. However, one example is given
here, to show how poor design of an application gave rise to symptoms which were
at first thought to indicate a loop.
Environment:
CICS and DL/I using secondary indexes. The programmer had made
changes to the application to provide better function.
Symptoms:
The transaction ran and completed successfully, but response was erratic
and seemed to deteriorate as the month passed. Towards the end of the
month, the transaction was suspected of looping and was canceled. No
other evidence of looping could be found, except that statistics showed a
high number of I/Os.
Explanation:
The programmer had modified the program to allow the user to compare on
the last name of a record instead of the personnel number, which it had
done in the past. The database was the type that grew through the month
as activity was processed against it.
It was discovered that in making the change, the program was no longer
comparing on a field that was part of the key for the secondary index. This
meant that instead of searching the index for the key and then going
directly for the record, every record in the file had to be read and the field
compared. The structure of the source program had not changed
significantly; the number of database calls from the program was the same,
but the number of I/Os grew from a few to many thousands at the end of
the month.
Note that these symptoms might equally well have pointed to a performance
problem, although performance problems are usually due to poorly tuned or
overloaded systems, and affect more than just one transaction. Performance
problems tend to have system wide effects.
What to do next
If you have already decided that you should refer the problem to the IBM Support
Center, you can find advice about dealing with the Center in “Chapter 18. IBM
program support” on page 303.
Manuals
“Manuals” means the manuals in the CICS Transaction Server for z/OS, Version 2
Release 1 library and the libraries for any other products you use with your
application.
Make sure that the level of any manual you refer to matches the level of the system
you are using. Problems often arise through using either obsolete information or
information about a level of the product that is not yet installed.
For a list of the destinations used by CICS, see the CICS System Definition Guide.
Use a copy of the appropriate messages and codes manual to look up any
messages whose meaning you do not know. Make sure that you also have some
documentation of application messages and codes for programs that were written at
your installation, as well as a copy of the CICS Messages and Codes manual.
Symptom strings
CICS produces symptom strings in CICS system and transaction dumps and in
message DFHME0116.
The symptom string provides a number of keywords that can be directly typed in
and used to search the RETAIN database. If your installation has access to the IBM
INFORMATION/ACCESS licensed program, 5665-266, you can search the RETAIN
database yourself. If you report a problem to the IBM Support Center, you are often
asked to quote the symptom string.
Although the symptom string is designed to provide keywords for searching the
RETAIN database, it can also give you significant information about what was
happening at the time the error occurred, and it might suggest an obvious cause or
a likely area in which to start your investigation.
Change log
The information in the change log can tell you of changes made in the data
processing environment that may have caused problems with your application
program. To make your change log most useful, include the data concerning
hardware changes, system software (such as MVS and CICS) changes, application
changes, and any modifications made to operating procedures.
Dumps
Dumps are an important source of detailed information about problems. Whether
they are the result of an abend or a user request, they allow you to see a snapshot
of what was happening in CICS at the moment the dump is taken. “Chapter 16.
Using dumps in problem determination” on page 255 contains guidance about using
dumps to locate problems in your CICS system. However, because they do only
provide a “snapshot”, you may need to use them in conjunction with other sources
of information relating to a longer period of time, such as logs, traces, and statistics.
Statistics are most often used in system tuning and diagnosis, but they also contain
information that can indicate problems with the way your application handles
resources. For example, you may notice from these statistics that tables are being
loaded, or programs linked, for which there is no known requirement.
You can also use statistics to check terminals, files, queues, and so on for
irregularities in their activity. For example, if a terminal has a number of errors
recorded for a particular transaction that equal the number of times that transaction
was run, this may indicate that an incorrect data stream is being sent to that
terminal. See the CICS Performance Guide for more information about using
statistics.
Monitoring
You can use CICS monitoring to provide information for debugging applications. In
addition to the system-defined event monitoring points (EMPs) that already exist
within CICS code itself, you can define user event monitoring points in your own
application programs by using the EXEC CICS MONITOR POINT command.
At a user EMP, you can add your own data (up to 256 counters, up to 256 clocks,
and a single character string of up to 8192 bytes) to fields reserved for you in
performance class monitoring data records. You could use these extra EMPs to
count how many times a certain event happens, or to time the interval between two
events. Your definitions in the Monitoring Control Table (MCT) specify the type and
number of fields that are available for your use within each task’s performance
record. For further information on the MCT see the CICS Resource Definition
Guide. See the CICS Application Programming Reference manual for programming
information on syntax and options of the MONITOR POINT command.
When your monitoring data has been collected, you can read it into a database
using, for example, the Service Level Reporter Version 2 (SLR II).
See the CICS Performance Guide for guidance about choosing performance tools.
See the CICS Supplied Transactions manual for information about the transactions
needed to invoke them.
The more you know about the information that was input at the terminal on which
the transaction failed, the better your chance of duplicating the problem in a test
environment. However, this information may not be precise, especially if there are
many fields on the input screen. You are recommended to provide a quick and easy
way for terminal operators to report problems, so that they can report the error
while they can still see the data on the screen (or at least remember more clearly
what it was).
The output from a transaction is sometimes easier to capture. If you have a locally
attached printer, you can make a copy. (The problem may be that the printer output
is incorrect.)
Even if the program does not use queues, look at the system queues for CEMT (or
your site replacement) and CSTL (and CDBC if you use DBCTL) to see if there are
any relevant messages.
The things you might want to look for in the queues are:
1. Are the required entries there?
2. Are the entries in the correct order?
3. Is the queue being written the same one that is being read?
Passed information
Be particularly careful when you are using the common work area (CWA) because
you only have one area for the entire system. A transaction may depend on a
certain sequence of transactions and some other program may change that
sequence. If you are using the CWA, you must also know if your CICS is split into
multiple MRO regions because there is an independent CWA for each MRO region.
Terminal user areas can have problems because the area is associated with a
terminal and not a particular transaction.
To do this, you need to use the appropriate utilities and diagnostic tools for the data
access methods that you have at your installation.
Check the various indexes in files and databases. If you have more than one
method of accessing information, one path may be working well but another path
may be causing problems.
When looking through the data in files, pay particular attention to the record layout.
The program may be using an out-of-date record description.
Traces
CICS provides a tracing facility that enables you to trace transactions through the
CICS components as well as through your own programs. CICS auxiliary trace
enables you to write trace records on a sequential device for later analysis.
For information about the tracing facilities provided by CICS, read “Chapter 15.
Using traces in problem determination” on page 225.
Chapter 11. Dealing with external CICS interface (EXCI) problems . . . . 203
Part 2 contains:
DFHAC2006 date time applid Transaction tranid program program name abend
primary abcode at termid.
The transaction abend can originate from several places, and the method you use
for problem determination depends on the source of the abend. The procedures are
described in the sections that follow. As you go through them, you might like to use
the worksheet that is included at the end of this section to record your findings
(“Worksheet for transaction abends” on page 39).
The transaction abend code and the abend message are recorded in the CSMT log.
Make a note, too, of any other messages you find there that might relate to the
abend, as they could provide additional valuable evidence.
Check also to see if any relevant messages have been sent to the transient data
destinations used by CICS to record messages. For a list of destinations used by
CICS, see the CICS System Definition Guide. Look in particular for any messages
about files, terminals, or printers that you might be attempting to use.
Symptom string
CICS produces a symptom string as part of the transaction dump. The symptom
string gives some details about the circumstances of the transaction dump. It might
show, for example, that the dump was taken because the transaction abended with
the abend code ASRA. If you refer the problem that caused the dump to be taken
to the IBM Support Center, they will use the symptom string to search the RETAIN
database for problems similar to it. For an introduction to symptom strings and their
contents, see “Looking at the symptom string in the dump” on page 45.
For an introduction to the types of transaction abend codes used by CICS and by
other IBM products, see the CICS Messages and Codes manual.
If you have received a user abend code, it can still be difficult to find out which
program is responsible for it unless you have adequate documentation. For this
reason, it is good practice for all programmers who issue abends from within their
programs to document the codes in a central location at your installation.
If, after reviewing the material in the CICS Messages and Codes manual, you
cannot find the cause of the problem, continue with the procedures described here.
The abend codes AICA, ASRA, ASRB, ASRD and AEYD are dealt with separately
because special procedures apply to them. If your abend code was something other
than these, use the procedures in “Last statement identification” on page 278, to
find the last command that was executed, and then turn to “Analyzing the problem
further” on page 38.
AICA abends
If your transaction terminated with abend code AICA, the transaction is likely to
have been in a loop. You can find detailed guidance about dealing with loops in
“Chapter 7. Dealing with loops” on page 149.
ASRA abends
CICS issues an ASRA abend code when it detects that a program check has
occurred within a transaction. Program checks can occur for a wide variety of
reasons, but you can find the nature of the error from the program interrupt code in
the program status word (PSW). The PSW is used by the machine hardware to
record the address of the current instruction being executed, the addressing mode,
and other control information. The PSW gives you the address at which the
program check occurred, and so it represents a record of the circumstances of the
failure.
ASRD abends
A transaction abends with code ASRD if:
v An application program attempts to invoke CICS macros.
v An application program attempts to access the CSA or TCA.
v An application program issues an EXEC CICS ADDRESS CSA command, and
attempts to access storage addressed by the pointer that is returned.
v A COBOL application program attempts to access the CSA via a BLL cell.
Any of the above causes a program check that CICS diagnoses as an ASRD
abend, rather than the usual ASRA abend. You can use the information in the PSW
to investigate the cause of an ASRD abend.
AEYD abends
If command protection is activated by the CMDPROT(YES) option in the system
initialization table (SIT), the AEYD transaction abend can occur. CICS terminates a
transaction with this code when an output parameter of an EXEC CICS command
addresses storage that the issuing transaction could not itself directly overwrite.
At the time of the abend, register 2 points to the parameter area containing the
invalid address. The trace should include an exception trace entry created by
DFHEISR. This entry should identify the parameter in error. If the abend is handled,
EXEC CICS ASSIGN ASRASTG, ASRAKEY, ASRASPC, and ASRAREGS can give
additional information.
The offset indicates the point in the program at which the program check occurred.
Note that the offset is derived from the PSW next sequential instruction address
and so may indicate the instruction after the one that failed. Unless the offset is
X'FFFFFFFF', turn to “What type of program check occurred?”.
If the offset appears as X'FFFFFFFF', CICS was unable to establish the location of
the program check. If this is the case, use the PSW to obtain the next sequential
instruction address. The PSW may be found in the following places:
v The TACB for the abend
v At the head of the formatted transaction dump
v Within the kernel error data block traced by exception trace point IDs AP 0781 or
AP 0783
Now note down the start and end addresses of the different program areas in the
transaction dump. Is the next sequential instruction address from the PSW in any of
the programs? If so, then that is the program in which the interrupt occurred. Use
the procedure described in “Locating the last command or statement” on page 278
to identify the last command executed.
If the address is outside all of the programs, one of two things is likely to have
happened.
v The program in which the program check occurred was running on your behalf
(for example, VSAM or DL/I), but not under CICS control. This is usually caused
by incorrect parameters being passed to the program, or parameters being
passed in the wrong sequence. These are usually caught and flagged with an
appropriate return code, but certain combinations can cause problems.
v Your program might have taken a “wild” branch into some other piece of storage.
If the address from the PSW ends in an odd number, this is probably the case,
as valid instructions are always on an even address. The address could be within
the CICS address space, or anywhere else in virtual storage.
Often, a wild branch is taken to address zero, because the register that should
contain the branch address is set to zero. The PSW usually contains address
X'00000004' after such a branch has occurred.
Check the register contents to see whether any of them contains the next
sequential instruction address from the PSW, or something close to it. This might
help you find out how you got to the wrong address.
If the PSW does point to an instruction in one of your programs, the next thing to
consider is the type of program check that occurred. Otherwise, turn directly to
“Analyzing the problem further” on page 38.
If any of these events occurs, CICS abnormally terminates the transaction with
abend code ASRA and issues message DFHSR0622 which identifies the DSA over
which the program attempted to write. This information is in the TACB and is traced
by exception trace point ID AP 0781. It is also useful to know the execution key of
the program at the time of the protection exception and whether the program was
executing in a subspace (CDSA, ECDSA, RDSA, ERDSA, UDSA, or EUDSA). This
appears in the TACB, exception trace point ID AP 0781 and at the head of the
formatted transaction dump.
It is still possible for CICS to abend when the problem is in the application. For
example, command protection only checks output parameters and does not
prevent the passing of fetch-protected storage as an input parameter to CICS.
When CICS attempts to read such storage, an ASRA abend occurs.
Transaction isolation
Transaction isolation protects the data associated with a user transaction from being
overwritten by EXECKEY(USER) programs invoked by other user transactions. If
transaction isolation is active, the occurrence of a protection exception in a new
transaction indicates a probable error in the transaction or program definition. An
interdependency may exist between two or more transactions. In a system running
without transaction isolation, a transaction can read or write to the task-lifetime
storage of another transaction. The Transaction Affinities Utility helps to identify
potential dependencies. Ideally such interdependencies should be removed. If
interdependencies cannot be removed, define all affected transactions with
ISOLATE(NO). For further details about defining transactions, see the CICS
Resource Definition Guide. For more information about the Transaction Affinities
Utility, see the CICS Transaction Affinities Utility Guide.
When migrating from a CICS 3.3 system to CICS Transaction Server for z/OS,
Version 2 Release 1, it may be helpful to alter all transaction definitions to include
the ISOLATE(NO) option. Then gradually change the definitions to use
Command protection
Command protection prevents CICS from updating storage if the storage address is
passed as a command output parameter by a transaction that is not authorized to
update that storage. The transaction terminates with abend code AEYD. The
exception trace entry AP 0779 supplies details of the failing program and command.
When migrating to a system with command protection enabled, EXEC commands
that pass unauthorized storage are identified and can be corrected.
Note: If you are using CSP/AD, CSP/AE, or CSP/RS, you must ensure that the
definitions for programs DCBINIT, DCBMODS, DCBRINIT and DCBNCOP
specify EXECKEY(CICS). These are all examples of programs that modify
global work areas set up by global user exit programs.
v If you are using DB2® and you use the DB2 message formatting routine
DSNTIAR, which is link-edited with your application programs, you should apply
the PTF for DB2 APAR PN12516, and relink-edit the applications using DSNTIAR
so that they may run in user key. If the applications are not re-link-edited after
this PTF is applied, they will have to run in CICS key. As a first step, until you
have applied this PTF, you can define the applications which use DSNTIAR with
EXECKEY(CICS).
If tracing was off at the time of the failure, you can find an indicator in the task local
work area for DFHDBAT. The indicator is set when CICS passes control to DBCTL,
and reset when DBCTL returns control to CICS.
To find the indicator, locate the eye-catcher for the TIE in the dump and then locate
the LOCLAREA eye-catcher that follows it. The indicator is at offset X'14' from the
start of the LOCLAREA eye-catcher. If the indicator byte is set to X'08', CICS has
passed control to DBCTL, and you should examine the IMS part of the transaction.
If the byte is set to X'00', DBCTL has returned control to CICS, and you should
investigate the CICS part of the transaction.
FEPI abends
For information about FEPI-associated abends in CICS or MVS, see the CICS Front
End Programming Interface User’s Guide.
If you have not yet done so, use the CMAC transaction or look in the CICS
Messages and Codes manual for an explanation of any message you may have
received, because it could offer a straightforward solution to your problem.
If the abend was clearly caused by a storage violation, turn directly to “Chapter 10.
Dealing with storage violations” on page 193. You know when CICS has detected a
storage violation, because it issues this message:
On reading this section, you may find that the abend was due to an application
error. In this case, you need to look at the application to find out why it caused the
abend. However, if you find that a CICS module seems to be in error, you need to
contact the IBM Support Center. Before doing so, you must gather this information:
v The name of the failing module, and the module level
v The offset within the module at which the failure occurred
v The instruction at that offset
v The abend type.
This section tells you how to find out all of these things, and contains the following
topics:
v “The documentation you need”
v “Interpreting the evidence” on page 44.
If system dumping is permitted for the dump code, and if system dumping has not
otherwise been disabled, a system dump will have been taken when the error was
detected. You can find out which dump relates to which message, because the time
stamps and the dump IDs are the same.
If a system dump was not taken when the abend occurred, you need to find out
why. Use the procedure described in “You did not get a dump when an abend
occurred” on page 173, and follow the advice given there. When you are sure that
dumping is enabled for the appropriate system dump code, you need to recreate
the system abend.
The formatted output for kernel domain (search for the eye-catcher ===KE) contains
summary information about the error. The internal trace table (eye-catcher ===TR)
contains the exception trace entry (if any) that was made at the time the error was
detected.
Later, you might find that storage summaries for the application, transaction
manager, program manager, dispatcher, and loader domains (formatting keywords
AP, XM, PG, DS, and LD, respectively) are also useful. In each case, level-1
formatting is sufficient in the first instance.
You can format and print the dump offline. Details of how to do this are given in the
CICS Operations and Utilities Guide.
You may need to copy the dump so that you can leave the system dump data set
free for use, or so that you have a more permanent copy for problem reporting.
Whether you look at the dump online or offline, do not purge it from the dump data
set until you have either copied it or finished with it—you might need to format other
areas later, or the same areas in more detail.
If the trace table contains more than one exception trace entry, it is likely that the
last one is associated with the dump. However, this might not always be the case,
and you should make sure that you have found the correct entry. Be aware, too,
that dumps can sometimes be requested without a corresponding exception trace
entry being made.
The exception trace entry gives information about what was happening when the
failure occurred, and data that was being used at the time.
For details of trace entries, see “Chapter 15. Using traces in problem determination”
on page 225.
The symptom string provides a number of keywords that can be directly typed into
RETAIN and used to search the RETAIN database. The possible keywords are
shown in Table 2. The keywords are used at the IBM Support Center to discover
duplicate problems, or problems that have already been reported by other users
and for which a solution is available.
If you have the IBM INFORMATION/ACCESS licensed program, 5665-266, you can
search the RETAIN database yourself.
If you report a problem to the IBM Support Center, you are often asked to quote the
symptom string.
Table 2. Symptom string keywords
Keyword Meaning
PIDS/ Product ID (CICS product number)
LVLS/ Level indicator (CICS release level)
RIDS/ Module name
PTFS/ Module PTF level
MS/ Message ID reporting error
AB/ Abend code
ADRS/ Address or offset indicator
PRCS/ Return code
PCSS/ CICS jobname
OVS/ Overlaid storage
FLDS/ Name of a field associated with problem
REGS/ Software register associated with problem
VALU/ Value of a named field or register
Although the symptom string is designed to provide keywords for searching the
RETAIN database, it can also give you significant information about what was
happening at the time the error occurred, and it might suggest an obvious cause or
a likely area in which to start your investigation. Amongst other things, it might
contain the abend code. If you have not already done so, look in the CICS
Messages and Codes manual to see what action it suggests for this abend code.
If the system is unable to gather much information about the error, the symptom
string is less specific. In such cases, it might not help you much with problem
determination, and you need to look at other parts of the dump. The kernel domain
storage summary is a good place to start.
The first thing you need to do is to find out which tasks are associated with the
error.
The task summary is in the form of a table, each line in the table representing a
different task.
The left-hand column of the task summary shows the kernel task number, which is
the number used by the kernel domain to identify the task. This is not the same as
the normal CICS task number taken from field TCAKCTTA of the TCA.
ERROR column. If you find a value of *YES* for a particular task, that task was in
error at the time the dump was taken.
Note: If the recovery routine that is invoked when the error occurs does not
request a system dump, you will not see any tasks flagged in error. In such a
case, the system dump is likely to have been requested by a program that is
In Figure 1 on page 46, you can see that kernel task number 0008 is shown to be in
error.
Look next at the STATUS column. For each task you can see one of the following
values:
v “***Running***”, meaning that the task was running when the system dump was
taken. Most of the time, only one task is shown to be running. If more than one
task is shown to be running, the different tasks are attached to separate TCBs.
v “Not Running”, meaning that the task is in the system but is currently not running.
It may, for example, be suspended because it is waiting for some resource, or it
may be ready to run but waiting for a TCB to become available.
v “KTCB”, referring to CICS control blocks corresponding to the CICS TCBs. These
are treated as tasks in the kernel task summary.
v “Unused”, meaning either that the task was in the system but it has now
terminated, or that there has not yet been a task in the system with the
corresponding task number. Earlier “Unused” tasks are likely to have run and
terminated, and later ones are likely never to have represented actual tasks. It is
most unlikely that you will ever need to distinguish between the two possibilities.
You are almost certain to find that the task shown to be in error has a status of
“***Running***”, as in the example of Figure 1 on page 46. Such a task would have
been running at the time the error was detected.
Tasks shown to be “Not Running” are less likely to be associated with the error, but
it is possible that one of these could have been flagged with an error. If you find this
to be so, the most likely explanation is that the task in error was attempting
recovery when, for some reason, it was suspended.
Two of the columns in the kernel task summary are particularly important in solving
problems that require the use of traces. They are the TRAN_# and KE_NUM
columns. The TRAN_# column for a task can contain:
v A number that matches the task number in the corresponding trace
v “TCP” for the CICS terminal control task
v Other character entries for CICS system tasks (for example, a component
identifier like “AP” for a CICS system task in the AP domain).
When you are working with trace output, you can use the number from the TRAN_#
column to identify entries associated with a user task up to the point at which that
task passes control to CICS. To identify the CICS processing associated with the
user task, you need to use the entry in the KE_NUM column of the kernel task
summary. This matches the KE_NUM shown in the full trace entries for the task,
and enables you to distinguish the CICS processing associated with the task you
are interested in from other CICS processing.
Look first in the dump for this header, which introduces the error report for the task:
==KE: KE DOMAIN ERROR TABLE
Next, you will see the kernel error number for the task. Error numbers are assigned
consecutively by the kernel, starting from 00000001. You might, for example, see
this:
=KE: ERROR NUMBER: 00000001
The error number tells you the number of program checks and system abends that
have occurred for this run of CICS. Not all of them have necessarily resulted in a
system dump.
Some kernel error data follows. If you want to find the format of this data (and, in
most cases, you will not need to), see the DFHKERRD section of the CICS Data
Areas. The next thing of interest is the kernel’s interpretation of what went wrong.
This includes the error code, the error type, the name of the program that was
running, and the offset within the program.
The error code gives you the system and user completion codes issued when the
abend occurred.
The error type tells you whether the error was associated with, for example, a
program check, a system abend, or an internal request for system recovery.
Figure 2. Storage report for a task that has experienced a program check
Next, there is a report of where the system has recorded that the error occurred,
and the circumstances of the failure. This is the general format of the information:
The program name (pppppppp) and offset (xxxxxxxx) are determined by searching
through the CICS loader’s control blocks for a program that owned the abending
instruction at the time of the abend. If this search does not find such a program, the
following text appears in the report:
PROGRAM QQQQQQQQ WAS IN CONTROL, BUT THE PSW WAS ELSEWHERE.
The program name (qqqqqqqq) reported, is the program that owns the current kernel
stack entry for the abending task. If this text appears, it may be possible to locate
the failing program using the method described in “Using the linkage stack to
identify the failing module” on page 51. The failing program name and offset are
also displayed in the section of the report immediately after the contents of the
registers have been reported. The format of this information is:
DATA AT PSW: AAAAAAAA MODULE: PPPPPPPP OFFSET: XXXXXXXX
If the failing program could not be located, the module name and offset are reported
as unknown. The possible reasons for the program not being located are:
v The failure occurred in an MVS loaded module
v The failing program had been released by the CICS loader before the dump was
taken
v A wild branch in the failing program caused the PSW to point to storage not
occupied by a CICS loaded program
Note that the accuracy of the program name and offset reported in a formatted
dump that was produced as the result of a program executing a wild branch cannot
be guaranteed.
After the kernel’s interpretation of the error, you will see one of these diagnostic
messages:
Error happened under the CICS RB
This means that the error was detected either when CICS code was executing, or
when an access method called by CICS was running (for example, VSAM or
QSAM). The CICS RB is the CICS request block, an MVS control block that records
the state of the CICS program.
Error did not happen under the CICS RB
After either of these messages, you next get some data that is likely to be related to
the problem. The data you get depends on whether or not the error happened
under the CICS RB.
If the error did not happen under the CICS RB, for example when CICS was calling
an MVS service, you get data based on two sets of registers and PSWs. The
registers and PSW of the CICS RB at the time of the error constitute one set. The
registers and PSW of the RB in which the error occurred constitute the other set.
This data will relate, very probably, to the execution of an SVC routine called by
CICS. The error may have occurred, however, during an IRB interrupt or in an SRB.
You can confirm whether this has happened by checking flags
KERNEL_ERROR_IRB and KERNEL_ERROR_SRB_MODE.
Note that only the values of the registers and PSW, not the storage they
address, are guaranteed to be as they were at the time of the error. The
storage that is shown is a snapshot taken at the time the internal system dump
request was issued. Data might have changed because, for example, a program
check has been caused by an incorrect address in a register, or short lifetime
storage is addressed by a register.
Also, in general, where error data is given for a series of errors, the older the error,
the less likely it is that the storage is as it was at the time of the failure. The most
recent error has the highest error number; it might not be the first error shown in
the output.
The registers might point to data in the CICS region. If the values they hold can
represent 24-bit addresses, you see the data around those addresses. Similarly, if
their values can represent 31-bit addresses, you get the data around those
addresses.
It could be that the contents of a register might represent both a 24-bit address and
a 31-bit address. In that case, you get both sets of addressed data. (Note that a
register might contain a 24-bit address with a higher order bit set, making it appear
like a 31-bit address; or it could contain a genuine 31-bit address.)
If, for any reason, the register does not address any data, you see either of these
messages:
24-bit data cannot be accessed
31-bit data cannot be accessed
This means that the addresses cannot be found in the system dump of the CICS
region. Note that MVS keeps a record of how CICS uses storage, and any areas
not used by CICS are considered to lie outside the CICS address space. Such
areas are not dumped in an MVS SDUMP of the region.
It is also possible that the addresses were within the CICS region, but they were
not included in the SDUMP. This is because MVS enables you to take SDUMPs
selectively, for example “without LPA”. If this were to happen without your
knowledge, you might think you had an addressing error when, in fact, the address
was a valid one.
This method is only valid if the abend has occurred in a module or subroutine that
has a kernel linkage stack entry. This is the case only where the module or
subroutine has been invoked by one of these mechanisms:
v A kernel domain call
v A kernel subroutine call
v A call to an internal procedure identified to the kernel
v A LIFO call
Routines that have been invoked by assembler language BALR instructions do not
have kernel linkage stack entries. Having found which task was in error from the
kernel’s task summary (see “Finding which tasks are associated with the error” on
page 46), you need next to find out which module was in error. The module name is
one of the things you need to give the IBM Support Center when you report the
problem to them.
Find the task number of the task in error from the KE_NUM column, and use this as
an index into the linkage stack entries. These are shown in the dump after the task
summary.
KE_NUM @STACK LEN TYPE ADDRESS LINK REG OFFS ERROR NAME
0031 0520A020 0120 Bot 84C00408 84C006D8 02D0 DFHKETA
0031 0520A140 01F0 Dom 84C0F078 84C0F18E 0116 DFHDSKE
0031 0520A330 0370 Dom 84CAA5A8 84CAACC2 071A DFHXMTA
0031 0520A6A0 0330 Dom 84F25430 84F25CF6 08C6 DFHPGPG
Int +00CC 84F254B6 0086 INITIAL_LINK
0031 0520A9D0 03C0 Dom 84F6C230 84E5DC40 0000 DFHAPLI1
Int +0EEA 84F6C66E 043E CICS_INTERFACE
0031 0520AD90 0108 Sub 0230B400 8230B8CA 04CA DFHEIQSP
0031 0520AE98 0290 Sub 82136D90 82137178 03E8 *YES* DFHLDLD
0520B128 Int +08FC 82136F26 0196 LDLD_INQUIRE
0520B128 Int +128E 821376CE 093E CURRENT_GET_NO_WAIT
0031 0520B128 0F70 Dom 84C6F8E0 84C72EA6 35C6 DFHMEME
Int +2CB6 84C6FA4E 016E SEND
Int +1486 84C72684 2DA4 CONTINUE_SEND
Int +350E 84C70DE4 1504 TAKE_A_DUMP_FOR_CALLER
0031 0520C098 03D0 Dom 84C52458 84C52F52 0AFA DFHDUDU
Int +08F4 84C5254A 00F2 SYSTEM_DUMP
Int +1412 84C53212 0DBA TAKE_SYSTEM_DUMP
The TYPE column in the example can contain any of the following entries:
Bot This marks the first entry in the stack.
A linkage stack for a task represents the sequence in which modules and
subroutines have been called during execution of a task. It provides a valuable
insight into the sequence of events up until the time of failure, and it also flags any
program or subroutine that was executing when the error was detected.
The modules and subroutines are shown in the listing in the order in which they
were invoked, so the first module you see is at the bottom of the stack, and the
second module is next from bottom. You often see DFHKETA and DFHDSKE,
respectively, in these two positions.
The last module or subroutine in the listing is at the top of the stack, and it
represents the last call that was made before the dump was taken. Assuming that
the system abend caused the dump to be taken, this is likely to be a routine
associated with dump domain.
The Support Center also needs to know the instruction at the offset. Locate the
address of the failing instruction in the dump, and find out what instruction is there.
It is sufficient to give the hex code for the instruction, but make sure you quote as
many bytes as you found from the PSW instruction length field.
Identify also the abend type from the program interruption code, so that you can
report that, too. It might, for example, be ‘protection exception’ (interruption code
0004), or ‘data exception’ (interruption code 0007).
Note: Entries made in the R/A MODE OVERRIDE columns are the value of the
RMODE and AMODE supplied on the DEFINE_PROGRAM call for that
program. If a REQUIRED_RMODE or REQUIRED_AMODE is not specified,
a – (dash) symbol appears in the appropriate column. If AMODE_ANY or
RMODE_ANY is specified, ‘ANY’ appears in the appropriate column. Other
values are shown as specified.
If CICS has stalled, turn directly to “What to do if CICS has stalled” on page 144.
If you have one or more tasks in a wait state, you should have already carried out
preliminary checks to make sure that the problem is best classified as a wait, rather
than as a loop or as poor performance. If you have not, you can find guidance
about how to do this in “Chapter 2. Classifying the problem” on page 7.
You are unlikely to have direct evidence that a CICS system task is in a wait state,
except from a detailed examination of trace. You are more likely to have noticed
that one of your user tasks, or possibly a CICS user task—that is, an instance of a
CICS-supplied transaction—is waiting. In such a case, it is possible that a waiting
CICS system task could be the cause of the user task having to wait.
For the purpose of this section a task is considered to be in a wait state if it has
been suspended after first starting to run. The task is not in a wait state if it has
been attached to the transaction manager but has not yet started to run, or if it has
been resumed after waiting but cannot, for some reason, start running. These are
best regarded as performance problems. Tasks that are ready to run but cannot be
dispatched might, for example, have too low a priority, or the CICS system might be
at the MXT limit, or the CICS system might be under stress (short on storage). If
you think you might have such a problem, read “Chapter 8. Dealing with
performance problems” on page 159.
Most tasks are suspended at least once during their execution, for example while
they wait for file I/O to take place. This is part of the regular flow of control, and it
gives other tasks a chance to run in the meantime. It is only when they stay
suspended longer than they should that a problem arises.
There are two stages in resolving most wait problems involving user tasks. The first
stage involves finding out what resource the suspended task is waiting for, and the
second stage involves finding out why that resource is not available. This section
focuses principally on the first of these objectives. However, in some cases there
are suggestions of ways in which the constraints on resource availability can be
relieved.
If you know that a CICS system task is in a wait state, it does not necessarily
indicate an error in CICS. Some system tasks spend long periods in wait states,
while they are waiting for work to do. For more information about waiting system
tasks, see “CICS system task waits” on page 142.
Note: Throughout this section, the terms “suspension” and “resumption” and
“suspended” and “resumed” are used generically. Except where otherwise
indicated, they refer to any of the SUSPEND/RESUME and WAIT/POST
processes by which tasks can be made to stop running and then be made
ready to run again.
Online inquiry is the least powerful technique, and it can only tell you what resource
a suspended user task is waiting for. This is enough information to locate the failing
area, but you often need to do more investigation before you can solve the
problem. The advantage of online inquiry is that you can find out about the waiting
task as soon as you detect the problem, and so you capture the data early.
Tracing can give you much more detail than online inquiry, but it involves significant
processing overhead. It must also be running with the appropriate options selected
when the task first enters a wait state, so this usually means you need to reproduce
the problem. However, the information it gives you about system activity in the
period leading up to the wait is likely to provide much of the information you need to
solve the problem.
A CICS system dump can give you a picture of the state of the CICS system at an
instant during the wait. You can request the dump as soon as you notice that a task
has entered a wait state, so it gives you early data capture for the problem.
However, the dump is unlikely to tell you anything about system activity in the
period leading up to the wait, even if you had internal tracing running with the
correct selectivity when the task entered the wait. This is because the trace table
If you are able to reproduce the problem, consider using auxiliary tracing and
dumping in combination.
If the task is suspended, the information that is returned to you includes the
resource type and/or the resource name identifying the unavailable resource. CEMT
INQ TASK displays the resource type of the unavailable resource in the HTYPE
field. The HVALUE field displays the resource name of the unavailable resource.
EXEC CICS INQUIRE TASK returns values in the SUSPENDTYPE and
SUSPENDVALUE fields which correspond to the resource type and resource name
of the unavailable resource.
Table 19 on page 73 gives a list of all the resource types and resource names that
user tasks might be suspended on, and references showing where to look next for
guidance about solving the wait.
You probably need a system dump of the appropriate CICS region to investigate the
wait. If you do not yet have one, you can get one using CEMT PERFORM SNAP or
CEMT PERFORM DUMP—but make sure the task is still in a wait state when you
take the dump. You subsequently need to format the dump using keywords for the
given resource type. Advice on which keywords to use is given, where appropriate,
in the individual sections.
When you look at the trace table, you can find trace entries relating to a particular
task from the task numbers that the entries contain. Each is unique to a task so you
can be sure that, for any run of CICS, trace entries having the same task number
belong to the same task.
For general guidance about setting tracing options and interpreting trace entries,
see “Chapter 15. Using traces in problem determination” on page 225.
Next, you need to ensure that tracing is done for the task that has the wait problem.
At first select special tracing for just that task, and disable tracing for all other tasks
by setting the master system trace flag off. Subsequently, you can select special
tracing for other tasks as well if it becomes clear that they are implicated in the
wait.
Each function has its own set of input and output parameters, and these, too, are
shown in the interpretation strings of the formatted trace entries. Input parameters
are shown in the trace entries made from point ID DS 0004, and output parameters
in the trace entries made from point ID DS 0005.
The values of the parameters can provide valuable information about task waits, so
pay particular attention to them when you study the trace table.
You need to use the dump formatting keyword DS to format the dispatcher task
summary. You probably need to look at other areas of the dump as well, so keep
the dump on the dump data set.
Table 4 on page 62 shows the parameters that set task summary fields, the
functions that use those parameters, and the domain gates that provide the
functions. Task summary fields that are not set by parameters are also identified (by
none in “Related parameter” column).
GET_NEXT DSBR
INQUIRE_TASK
ST none
Notes:
1. Field S (for STATE) of the dispatcher task summary has a wider range of values
than parameter STATE of DSBR functions GET_NEXT and INQUIRE_TASK.
Parameter STATE can only have the values READY, RUNNING, or
SUSPENDED. For the possible values of field S, see Table 3 on page 59.
2. Parameters ECB_ADDRESS and ECB_LIST_ADDRESS only relate to
SUSPAREA when the task has been suspended by the WAIT_MVS,
WAIT_OLDW, or WAIT_OLDC functions of gate DSSR.
3. Parameter ECB_LIST_ADDRESS is only valid for functions WAIT_MVS and
WAIT_OLDW, and not for function WAIT_OLDC.
4. If INTERVAL has been specified, the value of TIMEOUT DUE should be equal
to INTERVAL + TIME OF SUSPEND.
The major functions associated with the suspension and subsequent resumption of
tasks are provided by gate DSSR of dispatcher domain. When a task is to be
suspended or resumed, the requesting component calls gate DSSR with the
appropriate set of parameters. The required function is included in the parameter
list sent on the call, and the corresponding routines are executed by the dispatcher.
You can use trace to see the functions that are requested, and the values of
parameters that are supplied. See “Investigating waits—using trace” on page 57.
Table 5 lists the functions provided by the gate, and gives a brief summary of their
effect on the status of tasks in the CICS system.
Table 5. Functions provided by dispatcher gate DSSR
Function Effect on status of tasks
ADD_SUSPEND None—this does not cause
a task to be suspended.
INQUIRE_SUSPEND_TOKEN None.
The functions that are significant for problem determination are now described in
detail. It is necessary to consider their effects, the protocols that must be used, and
the parameters they use. If you are using trace, your approach to the wait problem
depends on the features of the function that caused the task to wait, so you must
find out early in your investigation how the task was suspended.
Some of the functions are available to users through the exit programming interface
(XPI). If you have any applications using these XPI functions, make sure that they
follow the rules and protocols exactly. For programming information about the XPI,
see the CICS Customization Guide.
The ADD_SUSPEND function has only to be called once for any sequence of
SUSPEND and RESUME calls for a particular task, because the same token can
be used each time.
The input and output parameters for the ADD_SUSPEND function are described in
Table 6 and Table 7, respectively.
Table 6. DSSR ADD_SUSPEND input parameters
Parameter Description
[RESOURCE_NAME] Provide default values for SUSPEND calls using
this suspend token. The defaults are overridden if
[RESOURCE_TYPE] values are specified on the SUSPEND call.
The input and output parameters for the DSSR DELETE_SUSPEND function are
described in Table 9 and Table 10 on page 66, respectively.
Table 9. DSSR DELETE_SUSPEND input parameter
Parameter Description
SUSPEND_TOKEN The suspend token to be discarded.
The input and output parameters for the DSSR SUSPEND function are described in
Table 11 and Table 12 on page 67, respectively.
Table 11. DSSR SUSPEND input parameters
Parameter Description
SUSPEND_TOKEN The suspend token that the task is to be
suspended against.
PURGEABLE The purgeable status of the task. Possible
values are:
YES|NO
The input and output parameters for the DSSR RESUME function are described in
Table 13 and Table 14, respectively.
Table 13. DSSR RESUME input parameters
Parameter Description
SUSPEND_TOKEN The suspend token that the task was
suspended against.
[COMPLETION_CODE] A user-supplied completion code.
WAIT_MVS
The WAIT_MVS function of gate DSSR causes a task to wait for an ECB, which
might be in a list of ECBs, to be posted by the MVS POST macro. The function is
available to users through the exit programming interface. A task made to wait by
the WAIT_MVS function becomes eligible to run again when the single ECB, or any
ECB in the list, has been posted.
WAIT_OLDW
The WAIT_OLDW function of gate DSSR causes a task to wait on a single ECB, or
list of ECBs. The task becomes eligible to run again when the single ECB, or any
ECB in the list, has been posted either by an MVS POST macro or by “hand
posting”.
WAIT_OLDC
The WAIT_OLDC function of gate DSSR causes a task to wait on a single ECB that
must be hand posted. A task made to wait by the WAIT_OLDC function becomes
eligible to run again when the ECB has been posted.
Notes:
1. The MVS workload manager monitoring environment is set to STATE=IDLE
when either:
v A conversational task is waiting for terminal input from its principal facility, or
v A CICS system task is waiting for work.
2. If the task is waiting on resource type ALLOCATE, the current MVS workload
manager monitoring environment is set to STATE=WAITING and either:
v RESOURCE=SESS_LOCALMVS if the session being waited on is a session
with another CICS region in the same local MVS image.
v RESOURCE=SESS_SYSPLEX if the session being waited on is a session
with a CICS region in another MVS image in the same sysplex.
v RESOURCE=SESS_NETWORK if the session being waited on is an ISC
session which may, or may not, be in the same MVS image.
3. If the task is waiting on resource type IRLINK, the current MVS workload
manager monitoring environment is set to STATE=WAITING,
RESOURCE=CONV. Look at the RMF™ workload activity report to see whether
the task continued beyond the current MVS monitoring environment. The
SWITCHED column in this report can contain the following values:
User tasks can be made to wait only on some of the resources. For each such
resource, there is a page reference showing you where to look for guidance about
dealing with the wait. The values in the column ’Purge status’ indicate whether the
suspending module permits normal task purging (such as that caused by the API
and CEMT purge commands) and purging caused by a deadlock timeout limit being
reached. Normal task purging is permitted if there is a ’Y’ (standing for ’yes’) in the
first column. If normal task purging is not permitted, there is an ’N’ (standing for
’no’) in this column. Deadlock timeout is permitted if there is a ’Y’ (standing for
’yes’) in the second column. If deadlock timeout is not permitted, there is an ’N’ in
this column.
The remaining resources are used only by CICS system tasks. If you have
evidence that a system task is waiting on such a resource, and it is adversely
affecting the operation of your system, you probably need to contact your IBM
Support Center. Before doing so, however, read “CICS system task waits” on
page 142.
Table 19. Resources on which a suspended task might be waiting
Resource type Resource name Suspending DSSR call Task Where to look next
Purge status module WLM wait type
(none) (none) DFHDUIO WAIT_MVS IO System only “CICS system task
waits” on page 142
(none) (none) DFHRMSL7 WAIT_MVS System only “CICS system task
TIMER waits” on page 142
(none) (none) DFHZNAC SUSPEND See System only “CICS system task
note 1 on waits” on page 142
page 72
CFDTLRSW CFDT pool name DFHFCDR SUSPEND User “File control waits” on
LOCK page 118
CSNC MROQUEUE DFHCRNP WAIT_MVS See System only “CICS system task
note 1 on waits” on page 142
page 72
DB2 LOT_ECB DFHD2EX1 WAIT_MVS User “CICS DB2 waits” on
OTHER_ page 92
Y Y PRODUCT
DB2_INIT (none) DFHD2IN1 WAIT_OLDC User “CICS DB2 waits” on
MISC page 92
Y Y
DB2CDISC name of DFHD2TM WAIT_OLDC User “CICS DB2 waits” on
DB2CONN MISC page 92
Y Y
DB2EDISA name of DFHD2TM WAIT_OLDC User “CICS DB2 waits” on
DB2ENTRY MISC page 92
Y Y
DBDXEOT (none) DFHDXSTM WAIT_MVS System only “CICS system task
MISC waits” on page 142
DBDXINT (none) DFHXSTM WAIT_MVS System only “CICS system task
MISC waits” on page 142
DBCTL DLSUSPND DFHDBSPX WAIT_MVS User “DBCTL waits” on
OTHER_ page 93
N N PRODUCT
DFHAIIN AITM DFHAIIN1 SUSPEND MISC System only “CICS system task
waits” on page 142
DFHCPIN CPI DFHCPIN1 SUSPEND MISC System only “CICS system task
waits” on page 142
Notes:
1. If there is a terminal associated with the task.
2. “bbbbb” is the block number.
3. “xxx” is literal.
4. The task has not yet started, because the system is at MXT.
5. These waits are used by the CICS/ESA® Front End Programming Interface and
are not discussed in this manual.
6. The task has not yet started because it is being held for transaction class
purposes.
Dispatcher waits
There are three reasons why CICS dispatcher might cause tasks to wait, and the
resource names or resource type associated with these are:
v OPEN_TCB
| v OPEN_DEL
v DSTSKDEF
| Your task needs an open TCB, but no suitable TCB is available, and a new TCB
| cannot be attached because the system is constrained by the MAXOPENTCBS
| limit. In this situation, CICS selects a currently idle TCB for termination, to allow the
| task to attach a TCB of the required type1. However, the attach cannot proceed until
| the deleted TCB’s termination is complete, otherwise the number of open TCBs
| would temporarily exceed MAXOPENTCBS.
A task may fail to run if the system is at MXT, or if the task is defined in a
transaction class that is at its MAXACTIVE limit.
If a task is waiting for entry into the MXT set of transactions, the resource type is
MXT, and the resource name is XM_HELD. If a task is waiting for entry into the
MAXACTIVE set of transactions for a TCLASS, the resource type is TCLASS, and
the resource name is the name of the TCLASS that the task is waiting for.
1. This process is referred to as TCB stealing: deleting a free TCB of one type in order to attach one of a different type.
Transaction summary
The transaction summary (Figure 6 on page 88) lists all transactions (user and
system) that currently exist. The transactions are listed in order of task number and
the summary contains two lines per transaction.
Depending on the value in the first line, the second line of the status field
may further qualify the transaction state. For each first line value, the
meaning of the second line is as follows:
PRE No data is displayed in the second line
TCLASS
The second line contains the name of the tclass that the transaction
is waiting to join.
CSNE 00031 10106100 C Yes ACT 00000003 None n/a 10164C00 00000000 00000000 00000000 1016C058 11542054
10A34B40 01000000 1017E048 00000000 00000000 10164C00 00000000
IC06 10056 10E2B200 T No ACT 089601C7 Terminal 10E167A0 1124F600 00000000 00000000 10114023 1016C9A0 11543610
10AC9300 00000000 00000000 1017E7E0 00000000 10E0F6A0 1124F600 00000000
IC12 10058 10E34C00 SD No ACT 050601AD None n/a 001DE600 00000000 00000000 10114023 1016C9F8 11545114
10AC93C0 00000000 1017E828 00000000 10E31400 001DE600 00000000
TA03 93738 10E0E000 T No ACT 088211E3 Terminal 10ED9000 0024B000 00000000 00000000 10114023 1016C738 115437B0
10AD3D40 00000000 00000000 1017E090 00000000 10117D60 0024B000 00000000
TA03 93920 10AFF200 T No TCL 00000000 Terminal 11214BD0 00000000 00000000 00000000 10114023 00000000 00000000
10AD3D40 DFHTCL03 00000000 00000000 00000000 00000000 10117680 00000000 00000000
TA03 93960 10E2D200 T No TCL 00000000 Terminal 10E573F0 00000000 00000000 00000000 10114023 00000000 00000000
10AD3D40 DFHTCL03 00000000 00000000 00000000 00000000 10E0F6C0 00000000 00000000
TA03 93967 10AFEA00 T No TCL 00000000 Terminal 10ECCBD0 00000000 00000000 00000000 10114023 00000000 00000000
10AD3D40 DFHTCL03 00000000 00000000 00000000 00000000 10117540 00000000 00000000
TA03 94001 10E34800 T No ACT 00000000 Terminal 10E2C3F0 00000000 00000000 00000000 10114023 00000000 00000000
10AD3D40 DF(AKCC) 00000000 00000000 00000000 00000000 10E31120 00000000 00000000
TA02 95140 10E2D300 T No ACT 0386150D Terminal 10E2C5E8 00057000 00000000 00000000 10114023 1016C790 11544754
10AD3C80 00000000 00000000 1017E510 00000000 10E0F320 00057000 00000000
TA02 95175 10E12C00 T No TCL 00000000 Terminal 10E937E0 00000000 00000000 00000000 10114023 00000000 00000000
10AD3C80 DFHTCL02 00000000 00000000 00000000 00000000 10E0F100 00000000 00000000
TA02 95187 10E0B000 T No TCL 00000000 Terminal 10EA95E8 00000000 00000000 00000000 10114023 00000000 00000000
10AD3C80 DFHTCL02 00000000 00000000 00000000 00000000 10117800 00000000 00000000
TA02 95205 10E2D600 T No MXT 00000000 Terminal 10E837E0 00000000 00000000 00000000 10114023 00000000 00000000
10AD3C80 DF(AKCC) 00000000 00000000 00000000 00000000 10E0F780 00000000 00000000
TA04 96637 10E33000 T No ACT 060408E7 Terminal 10E05BD0 00057600 00000000 00000000 10114023 1016C7E8 115457C8
10AD3E00 00000000 00000000 1017E558 00000000 10E31040 00057600 00000000
TA04 96649 10E34000 T No TCL 00000000 Terminal 10AE89D8 00000000 00000000 00000000 10114023 00000000 00000000
10AD3E00 DFHTCL04 00000000 00000000 00000000 00000000 10E312C0 00000000 00000000
F121 99305 10E2D800 T No ACT 020C1439 Terminal 10EA93F0 00060000 00000000 00000000 10114023 1016C898 115423FC
10AD3BC0 AB(AFCY) 00000000 00000000 1017E708 00000000 10E0F920 00060000 00000000
TS12 99344 10AFED00 T No MXT 00000000 Terminal 10E499D8 00000000 00000000 00000000 10114023 00000000 00000000
10AD6B40 00000000 00000000 00000000 00000000 101178C0 00000000 00000000
MXT summary
The MXT summary indicates whether CICS is currently at MXT and shows the
current number of queued and active transactions. To check the status of an
individual transaction, consult the main transaction summary (Figure 6 on page 88).
* NOTE: these values were reset at 18:00:00 (the last statistics interval collection)
*** Note that the 'Total Attaches' figures were reset at 18:00:00 (the last statistics interval collection)
The suspended task is never resumed, and holds its MXT slot until CICS is
terminated. You must cancel CICS to remove this task as you will be unable to
quiesce the system. You cannot purge or forcepurge the task.
A user task cannot explicitly acquire a lock on a resource, but many of the CICS
modules that run on behalf of user tasks do lock resources. If this is a genuine wait,
and the system is not just running slowly, this could indicate a CICS system error.
Turn to the lock manager summary information (Figure 8 shows an example of this).
Table 20 describes each of the fields in the lock manager summary information.
Table 20. Fields in the lock manager summary information
Field Description
LOCK NAME The name given to the lock by the domain that originally issued the
ADD_LOCK command.
LOCK TOKEN The token assigned by the lock manager to uniquely identify the lock.
OWNER A token that uniquely identifies the owner of the lock. It is blank unless a
task currently holds the lock, in which case the KE_TAS number of the
task is given.
The first step is to establish which lock the suspended task is waiting on. Obtain the
KE_TAS number from the dispatcher domain summary for the suspended task and
match this with an OWNER in the ‘LOCK WAIT QUEUE’ section of the lock
manager summary information.
In the example, only one task is suspended and waiting to obtain the LD_GBLOK
lock. The owner (KE_TAS identifier) of this task is 03B0B3A0.
If the mode of the lock is SHR (shared), you will not be able to proceed any further
and you will have to contact your IBM Support Center.
If the mode is EXCL (exclusive), the identifier of the task that currently holds the
lock is given in the OWNER field. In the example, the task that currently has the
lock—LD_GBLOK—is 030B0AAD0. Because the OWNER field is the KE_TAS
identifier of the task, you can find out from the dispatcher domain summary the
status, dispatcher task number, and TCA address of the task that currently holds
the lock.
When you have all this information ready, contact the IBM Support Center and
report the problem to them.
ECB “PSTDECB”—DLI code lock, PSB load I/O, or DMB load I/O: If you find
that a task is waiting on ECB PSTDECB, it indicates either an error within CICS or
IMS code, or some hardware fault preventing a PSB or DMB from being loaded.
If you have no evidence of a hardware fault, contact the IBM Support Center and
report the problem to them.
You cannot purge the task when it is in this state. Message DFHAP0604 is issued
at the console if an attempt to forcepurge the task is made. Forcepurge processing
is deferred until a thread is acquired.
You can increase the number of threads available for the DB2ENTRY with a SET
DB2ENTRY ( ) THREADLIMIT(nn) command. You can increase the number of
threads available for the pool with a SET DB2CONN THREADLIMIT(nn) command.
If you increase the THREADLIMIT value, CICS posts tasks to retry acquisition of a
thread.
You cannot purge the task when it is in this state. Message DFHAP0604 is issued
at the console if an attempt to forcepurge the task is made. Forcepurge processing
is deferred until a TCB has been acquired.
You can increase the number of TCBs permitted with a SET DB2CONN TCBLIMIT
command. If you increase the TCBLIMIT value, CICS posts tasks to retry
acquisition of a DB2 subtask.
DBCTL waits
Read this section if you have any of the following problems:
v You have attempted to connect to DBCTL using the CICS-supplied transaction
CDBC, but the connection process has failed to complete.
v You have a user task in a wait state, and you have found that it is waiting on
resource type DBCTL, with resource name DLSUSPND.
v You have attempted to disconnect from DBCTL using the CICS-supplied
transaction CDBC, but the disconnection process has failed to complete.
In phase 1, CDBC simply passes the request for connection to IMS, and returns. It
is very unlikely for a wait to occur during this phase, unless there is an error in
CICS code. In such a case, you would see this message displayed whenever you
inquired on the connection status using CDBI:
DFHDB8291I DBCTL connect phase 1 in progress.
In phase 2, IMS processes the request asynchronously, and returns to CICS when
connection is complete. Until the connection is complete, you see this status
message displayed whenever you inquire with CDBI:
DFHDB8292I DBCTL connect phase 2 in progress.
If this phase fails to complete, the failure is associated with IMS. See the IMS
Diagnosis Guide and Reference manual for guidance about debugging the problem.
If disconnection fails to complete, you can inquire on CDBT using, for example,
CEMT INQ TASK to see how far disconnection has progressed. You will probably
find that CDBT is waiting on resource type DBCTL and resource name DLSUSPND,
in which case the request is being processed by DBCTL.
v If CDBT is waiting on DBCTL, what you do next depends on whether you have
requested “orderly” or “immediate” disconnection.
– If you have requested “orderly” disconnection, it is likely that DBCTL is waiting
for conversational tasks to finish. You can override an “orderly” disconnection
by requesting “immediate” disconnection, in which case the process should
end at once.
– If you have requested “immediate” disconnection, and this does not happen,
there is an unexpected wait within IMS. See the IMS Diagnosis Guide and
Reference manual for guidance about investigating the problem.
v If CDBT is not waiting on DBCTL, this indicates a problem with CICS code.
Contact the IBM Support Center for further assistance.
EDF waits
A user task is made to wait on resource type EDF and resource name DBUGUSER
when, under the EDF session, CICS has control for EDF processing.
If you do encounter any of these waits, look at the MVS console for messages
prefixed with ‘IXG’. These are the MVS system logger messages and may provide
further information about the cause of the wait. The MVS system console may also
reveal evidence of resource contention within MVS, a possible cause of a log
manager wait.
If the task is writing to a journal on an SMF log, the journal name is the name of the
journal.
The task may be purged if the log stream is not DFHLOG, the primary system log.
KC_ENQ indicates that CICS code acting for a task has issued an EXEC CICS
ENQ command or a DFHKC TYPE=ENQ macro. If there is an extended wait for no
apparent reason, this might indicate an error within CICS. If that turns out to be the
case, contact the IBM Support Center.
USERWAIT indicates that a task has issued an EXEC CICS WAIT EVENT
EXTERNAL or an EXEC CICS WAITCICS command.
EKCWAIT indicates that a task has issued an EXEC CICS WAIT EVENT command.
If the wait is prolonged, you should identify the event being waited on, and:
v Check that the EXEC CICS WAIT EVENT command specified the correct event.
v Check for problems with the task that should be completing the work for the
specified event. It might be waiting or looping, it might have a performance
problem, or it might have failed completely.
If the resource name for the wait is SINGLE, CICS, or LIST, look at the entry in the
SUSPAREA column of the dispatcher summary in the dump. The type of value it
contains depends on the resource name:
v For SINGLE or CICS, it is the address of an ECB
v For LIST, it is the address of a list of ECBs.
(The contents of the SUSPAREA entry are not significant for TERMINAL, because
this type of wait is subject to the dispatcher RESUME function. For more
information about debugging terminal waits, see “Terminal waits” on page 101.)
Check the contents of the SUSPAREA entry. Does it contain a valid address? That
is, is it within the CICS address space, and actually pointing at an ECB, or a list of
ECBs?
If you find an invalid address: It is possible that a storage overlay is the cause of
the wait problem. If you suspect this to be the case, turn to “Chapter 10. Dealing
with storage violations” on page 193 for further advice. However, note that this is
likely to be a “random” overlay, and such problems are often very difficult to solve.
From the kernel information in the dump, find out which code issued the DFHKC
macro call. If you think that CICS has passed an incorrect address, contact the IBM
Support Center, and report the problem to them.
If the ECB does not lie within an area that you can control, refer the problem to the
IBM Support Center.
Storage waits
Read this section if you have found that a task is waiting for a long time on any of
the resource types CDSA, UDSA, ECDSA, EUDSA, ERDSA, SDSA, ESDSA, or
RDSA. Waits on these resources occur when tasks make unconditional storage
requests (SUSPEND=YES) that cannot be satisfied. The type is CDSA, UDSA,
SDSA, or RDSA for storage requests below the 16MB line, and ECDSA, EUDSA,
ESDSA, or ERDSA for storage requests above the line.
Note that, if conditional requests are made (SUSPEND=NO), tasks are not
suspended on these resources. Instead, an exception response is returned if the
request cannot be satisfied.
CICS automatically takes steps to relieve storage when it is under stress, for
example by releasing storage occupied by programs whose current use count is 0.
In addition, your task may be automatically purged if it has waited for storage longer
than the deadlock time-out parameter specified in the installed transaction definition.
The first step is to get a CICS system dump, and format it using the formatting
keyword SM. The way you interpret the dump to investigate each of the above
possibilities is dealt with in the sections that follow.
If the suspended task has made a reasonable GETMAIN request, you next need to
see if the system is approaching SOS.
To see if this could be the cause of the wait, look at the DSA summary in the
formatted dump. This tells you the current free space in each DSA, both in bytes
and as a percentage of the total storage. It also tells you the size of the largest free
area, that is, the biggest piece of contiguous storage. (“Contiguous storage” in this
context means storage not fragmented by other records. It is accepted that records
too large to fit in a single CI can be split across two or more CIs that are not
necessarily contiguous.)
If the largest free area is smaller than the requested storage, this is likely to be the
reason why the task cannot obtain its requested storage.
If the amount of free space is unexpectedly small, look at the task subpool
summary. If a task has made an unusually large number of GETMAIN requests, this
could indicate that it is looping. A looping task might be issuing GETMAIN requests
repetitively, each for a reasonable amount of storage, but collectively for a very
large amount. If you find evidence for a looping task, turn to “Chapter 7. Dealing
with loops” on page 149.
If your task has made a reasonable request and the system seems to have
sufficient free storage, you next need to see if fragmentation of free storage is
causing the GETMAIN request to fail.
For general information about dealing with enqueue waits, see “Enqueue waits” on
page 115.
These are the two most likely reasons why a task that has issued an unconditional
WRITEQ TS request might be suspended on resource type TSAUX:
1. The task has issued a request requiring too large a piece of temporary storage.
2. The task has issued a request requiring a reasonable amount of temporary
storage, but there is too little available.
This could indicate that the amount of auxiliary storage is becoming exhausted.
Otherwise, it could be that there is quite a large amount of auxiliary storage left,
but the storage is too fragmented for the request to be satisfied.
The first step is to get a CICS system dump, and format it using the formatting
keyword TS to show the temporary storage control blocks. Include formatting
keywords SM and KE, too, as you might need to refer to the summaries for these
two components as well. The way you analyze the dump to investigate the cause of
the problem is described in the sections that follow.
Is temporary storage close to being exhausted?: It could be that your task has
made a reasonable request for temporary storage, but the amount of unallocated
space is close to exhaustion.
To see if this could be the cause of the wait, look at the temporary storage
summary in the formatted dump. If the current free space is very small, this is likely
Look also at the trace. If a task has made an unusually large number of WRITEQ
TS requests, it could be looping. A looping task might be issuing WRITEQ TS
requests repetitively, each for a reasonable amount of storage, but collectively for a
very large amount. If you find evidence for a looping task, turn to “Chapter 7.
Dealing with loops” on page 149.
If your task has made a reasonable request and the system seems to have
sufficient unallocated temporary storage, you next need to see if fragmentation of
unallocated storage is causing the WRITEQ TS request to fail.
The following fields in the summary are of interest should your task be suspended
on resource type TSAUX:
Number of control intervals in data set:
Number of control intervals currently in use:
Available bytes per CI:
For control intervals of 4K, the available bytes per CI figure is 4032.
If your task is attempting to a write a record that is smaller than or equal to the
available bytes per CI figure (including its record header which is 28 bytes long),
this means that no control interval has the required amount of contiguous space to
satisfy the request.
If your task is attempting to write a record that is longer than the available bytes
per CI figure, CICS splits the record into sections of a length equal to this figure.
CICS then attempts to store each section in a completely empty control interval,
and any remaining part of the record in a control interval with the contiguous space
to accommodate it. If your task is waiting on resource type TSAUX after having
attempted to write a record longer than the available bytes per CI figure, either of
the following has occurred:
v There are not enough available completely empty control intervals to
accommodate all the sections
(CIs in data set - CIs in use) < (record length / available bytes per CI)
v No control interval has enough contiguous space to accommodate the remainder.
The length of time that a task has the lock on a temporary storage queue depends
on whether or not the queue is recoverable. If the queue is recoverable, the task
has the lock until the logical unit of work is complete. If it is not recoverable, the
task has the lock for the duration of the temporary storage request only.
If tasks in your system are frequently made to wait on temporary storage queues,
consider the following:
v Are tasks that are performing operations on the same temporary storage queue
intended to do so, or is the ID of the queue unintentionally not unique?
v Is it possible to create more temporary storage queues to reduce the contention
between tasks?
v If the queue in question is recoverable, is it possible to make tasks relinquish
control of it more quickly? Consider reducing the size of UOWs, or making
conversational tasks pseudoconversational.
Terminal waits
Read this section if you have any of the following problems:
v A task should have started at a terminal, but has failed to do so.
v A task is waiting on a resource type of KCCOMPAT, with a resource name of
TERMINAL.
Note that, if you have one or more unresponsive terminals, that is terminals that are
showing no new output and accepting no input, this does not necessarily indicate a
terminal wait. If you have this problem, use CEMT INQ TERMINAL to find the
transaction running at the terminal, and then CEMT INQ TASK to find out what
resource that task is waiting on. When you know that, look at Table 19 on page 73
to find where you can get further guidance.
If all the terminals in the network are affected, and CICS has stalled, read “What to
do if CICS has stalled” on page 144 for advice about how to investigate the
problem.
If yours is a genuine terminal wait, remember when you carry out your investigation
that terminals in the CICS environment can have a wide range of characteristics. A
terminal is, in fact, anything that can be at the end of a communications line. It
could, for example, be a physical device such as a 3270 terminal or a printer, or a
batch region, or it could be another CICS region connected by an interregion
communication link, or it could be a system that is connected by an LUTYPE6.1 or
APPC (LUTYPE6.2) protocol. If LUTYPE6.1 is in use, the other system might be
another CICS region or an IMS region. With APPC (LUTYPE6.2), the range of
possibilities is much wider. It could include any of the systems and devices that
support this communications protocol. For example, apart from another CICS
region, there might be a PC or a DISOSS system at the other end of the link.
If you eventually find that the fault lies with a terminal, or a resource such as
DISOSS, the way in which you approach the problem depends on what type it is. In
some cases, you probably need to look in appropriate books from other libraries for
guidance about problem determination.
Your strategy must then be to find where in the communication process the fault
lies. These are the basic questions that must be answered:
1. Is the problem associated with the access method?
2. If the access method has returned, or has not been involved, is terminal control
at fault?
3. If terminal control is working correctly, why is the terminal not responding?
To answer most of these questions, you will need to do some offline dump analysis.
Use CEMT PERFORM SNAP to get the dump, and then format it using the
formatting keyword TCP. Do not cancel your task before taking the dump. If you
do, the values in the terminal control data areas will not relate to the error.
What type of terminal is not responding?: You can check the terminal type
either online, using a system programming command, or offline, by looking at the
appropriate TCTTE in the formatted system dump.
Online method: Use the transaction CECI to execute the system programming
command EXEC CICS INQUIRE TERMINAL DEVICE. This returns one of the
terminal types identified in the CICS Resource Definition Guide.
Offline method: Look at the formatted dump output you have obtained for keyword
TCP. First, identify the TCTTE relating to the terminal, from the four-character
terminal ID shown in field TCTTETI. Now look in field TCTTETT, and read the
1-byte character that identifies the type of terminal. You can find what terminal type
is represented by the value in the field from the description given in the CICS Data
Areas.
What type of access method is in use?: You can use both an online method
and an offline method for finding the type of access method being used by the
terminal that is not responding.
Online method: Use the CECI transaction to execute the system programming
command EXEC CICS INQUIRE TERMINAL ACCESSMETHOD. This returns the
access method in use by the terminal.
Offline method: You can find the access method for the terminal from the TCTTE.
Look in field TCTEAMIB, which is the byte name definition for the access method.
The CICS Data Areas relates values to access methods.
If you have any other access method, for example TCAM, you need to adapt the
guidance given here accordingly.
The first step is to look in the CSNE log to see if there is an error message that
explains the wait. If it contains an error code, you can find out what it means from
the VTAM Messages and Codes for MVS and VSE manual.
Look next for any NACP error codes in fields TCTEVRC5, TCTEVRC6, TCTEVRC7,
and TCTEVRC8 of the terminal table entry, TCTTE. Look also for any SNA sense
code in field TCTEVNSS.
Is the problem associated with VTAM?: You can find the VTAM process status
with respect to the waiting task from fields TCTEICIP and TCTEIDIP in the TCTTE.
The following are the values you might find there, and their interpretations:
TCTECIP command request in progress
TCTEDIP data request in progress
Either of these status values indicates that a VTAM request is in progress, and that
the VTAM RPL is active. A response is expected either from VTAM, or from the
terminal. You can find the address of the RPL from field TCTERPLA, unless the
request was for a RECEIVE on an APPC session, in which case you can find the
RPL address from field TCTERPLB.
If a VTAM request is not in progress, the next field of interest is in the VTAM
system area of the TCTTE. Find four bytes of VTAM exit IDs, starting at field
TCTEEIDA. If any are nonzero, the VTAM request has completed. Nonzero values
suggest that VTAM is not involved in the wait. You can find the meanings of the
values from the VTAM module ID codes list in the CICS User’s Handbook.
If you suspect that the problem is associated with VTAM, consider using either
CICS VTAM exit tracing or VTAM buffer tracing. Both of these techniques can give
you detailed information about the execution of VTAM requests. For guidance about
using the techniques, read the appropriate sections in “Chapter 15. Using traces in
problem determination” on page 225.
If field TCTVAA1 points to a TCTTE on the active chain, check that the TCTTE of
the terminal your task is waiting for is included in the chain. You can find this out by
following the chain using the “next” pointer, field TCTEHACP of the TCTTE. If it
does not contain the address of the next TCTTE on the chain, it contains either of
these values:
X'FFFFFFFF' this is the last TCTTE on the chain
X'00000000' this TCTTE is not on the active chain
If you find a value of X'00000000', report the problem to the IBM Support Center.
VTAM in use—is the terminal at fault?: If you have found that the access
method and terminal control are not causing the wait, the terminal itself must be
waiting for some reason. You need now to look at some fields in the TCTTE for the
terminal to find its status.
CICS system dumps contain an index to the VTAM terminal entries. It appears in
the terminal control (TCP) summary section of the dump.
Information about the status and attributes of the VTAM terminals appears in an
interpreted form at the end of the control block for each terminal entry. The
information shown depends on the attributes of the terminal.
The example in Figure 9 on page 106 shows the index followed by a terminal entry
with its interpreted status and attribute information.
The values that are given below for fields in the TCTTE are not the only
possibilities, but they show important things about the terminal status. If you find
any other values for these fields, look in the CICS Data Areas to find out what they
mean.
The following are the questions that need to be asked, and some values that could
provide the answers.
1. Is the terminal in service? Look at field TCTTETS of the TCTTE, to find the
terminal status. The values that indicate why a terminal was failing to respond
include:
TCTTESPO = 1 and TCTTESOS = 1 terminal out of service
TCTTESOS = 1 only terminal in error recovery
Look also at field TCTESEST, to find the session status with respect to
automatic transaction initiation (ATI) for the terminal. Some of the values you
might see are:
TCTESLGI = 0 CREATESESS(NO) in TYPETERM definition
TCTESLGI = 1 CREATESESS(YES) in TYPETERM definition
TCTESLGT = 1 recovering CREATESESS
If all three bits are set, so the value of the byte is TCTENIS, the node is in
session.
You next need to see if the terminal is logging off, or if it has already been
logged off. The fields of interest are TCTEINND, TCTEINBD, and TCTEIPSA.
The values to look for are:
TCTENND = 1 the terminal is to be logged off
TCTENBD = 1 the terminal is logging off because of an error
TCTEPSA = 1 the session with the terminal ended abnormally
—look for any explanatory message on CSMT
If any of these bits are set, the terminal might not be able to respond to the
waiting task.
5. Should the terminal respond to the task? Field TCTEIPRA tells you this:
TCTEPRA = 1 the terminal should respond
Tools you can use for debugging terminal waits when VTAM is in
use
Amongst your debugging tools, two are likely to be of particular use for investigating
terminal waits in a VTAM environment. They are:
v VTAM buffer trace. This is a feature of VTAM itself, and you need to see the
appropriate manual in the VTAM library for details of how to use it.
v CICS VTAM exit trace. This is a feature of CICS, and you can control it from the
CETR panel.
For a description of the use of these two types of tracing in CICS problem
determination, see “Chapter 15. Using traces in problem determination” on
page 225.
Your task is waiting on a physical terminal: If a session has been acquired and
it has not failed, your task is likely to be waiting for some response from a task in
the other region. This can apply to any of the interregion or intersystem
communication activities—function shipping, asynchronous processing, transaction
routing, distributed transaction processing, or distributed program link. No matter
which of these applies, it is most likely that the other region is not responding
because the related task there has been suspended.
You need to identify the related task in the remote region, and find out the resource
it is waiting on. When you have done that, see Table 19 on page 73 to find out
which part of this section to turn to next.
Investigating the related task in the remote region: The first thing to do is to
identify the region that is not responding to your local task.
If the task is using interregion communication (IRC), look first at the name of
the resource being waited on, returned together with resource type IRLINK by
CEMT INQ TASK. The first four characters give you the SYSIDNT of the remote
CICS region.
If the task is using intersystem communication (ISC), you need to look in field
TCTTEIST of the TCTTE, which points to the ISC system table entry. The first field
in the system table entry is the identity of the remote region.
When you have identified the region, you need to take a system dump of it. You
can do that either by using the CEMT PERFORM DUMP command in that region,
or by using the MVS DUMP command. Take a system dump of the local region, too.
First find the TCTTE for the task in the local region. The way you find the TCTTE
for the task in the remote region depends on whether you are using LUTYPE6.1
sessions (or IRC) or APPC sessions:
v For LUTYPE6.1 sessions and IRC sessions, look in local control block TCTENIB,
the TCTTE extension for the NIB descriptor, at field TCTESQP. This gives you
the session qualifier pair for the session. It provides the terminal ID associated
with the local task, concatenated with the terminal ID associated with the remote
task.
Now go to the dump of the remote region, and use the terminal ID to locate its
TCTTE. Check in field TCTESQP of TCTENIB to make sure that the session
qualifier pair matches that in the local system. It should be made up of the same
terminal IDs, but with their order reversed.
v For APPC sessions, look in local control block TCTTELUC, the APPC extension,
in field TCTESII. Ignoring the high-order byte, this gives you the session instance
identifier of the session.
Now go to the dump of the remote region, and use the session instance identifier
you have found for the remote task to locate its TCTTELUC. The TCTTE
precedes the TCTTELUC in the dump.
When you have confirmed that you have located the correct TCTTE, look in field
TCTTECA. This gives you the TCA address of the task that is not responding.
Using the TCA address as the entry point, you can now investigate the reason why
the task has not responded. It is very likely that it has been suspended because
some resource is unavailable. Look in the dispatcher and transaction manager
summaries. If you can identify your task, you can see what resource it is waiting on.
When you have identified the resource, turn to the appropriate section in this
section for guidance about investigating waits on that resource.
The implication of waits on any of these VTAM terminal resource types are as
follows:
Resource type ZC
If your task is waiting on a resource name of DFHZCRQ1, it is waiting for I/O to
complete. The task is attempting to complete one of the following:
v RESETSR
v A send synchronous data flow
The task waits for the time specified in the RTIMEOUT value of the profile used by
the transaction rounded up to the nearest multiple of 16.78 seconds. If the task
times out, it receives either an AKCT or AZCT abend.
If your task is waiting on a resource name of DFHZEMW1, the error message writer
module, DFHZEMQ, is waiting for the completion of I/O. If a timeout value exists
and is exceeded, the suspend expires.
If your task is waiting on a resource name of DFHZRAQ1, this means a READ has
been issued. The task is resumed once the I/O operation is complete. If a timeout
value exists and is exceeded, the suspend expires.
If your task is waiting on a resource name of DFHZRAR1, this means a READ has
been issued. The task is resumed once the I/O operation is complete. If a timeout
value exists and is exceeded, the suspend expires.
The method of debugging is the same in each case. You need to consider the
access method, terminal control, and the “terminal” itself.
For interregion and intersystem communication, the remote region or system is the
terminal. Its status can be found using the same online or offline techniques that
you would use to find the status of a physical terminal. The status may lead you to
suspect that the task running in the remote region is the cause of the problem, and
you then need to investigate why that task is waiting. So you could find that what
started as a terminal wait might, after all, be a wait on some other type of resource.
| IIOP waits
| A request receiver DFHIIRR task suspends with resource type IIRR and resource
| name SOCBNOTI when it has no work to do and the TCPIP connection is still
| open. It is resumed by a NOTIFY gate when IIRR is told there is another request
| from the sockets domain or a reply has come in from the request streams domain.
| A request processor DFHIIRP task suspends with resource type IIRP and resource
| name NOTI when it is waiting for requests or replies. It is resumed by a NOTIFY
| gate when IIRP is told there is another request or reply from the request streams
| domain.
The resource types that might be associated with the wait are:
v TD_INIT
v TDEPLOCK
The resource name is the transient data queue name, except in the case of
TD_INIT, whose resource name is DCT.
You are unlikely to see any evidence for this type of wait, unless you have trace
running during initialization with DS level-1 tracing selected. An error at this stage
would be likely to cause CICS to stall (see “CICS has stalled during initialization” on
page 144), or to terminate abnormally.
You can find further guidance information about the constraints that apply to tasks
writing to intrapartition destinations in the CICS Application Programming Guide. For
more details of the properties of recoverable transient data queues, see the CICS
Resource Definition Guide.
If you have a task suspended on resource type ENQUEUE, and a value of TDNQ,
the task has been suspended while attempting to read, write or delete a logically
recoverable queue because a required enqueue is currently held by another task.
Note: For general information about dealing with enqueue waits, see “Enqueue
waits” on page 115. Issuing a CEMT INQUIRE UOWENQ command reveals
the name of the queue and whether the enqueued read or write is required
by the task. If the task is enqueued against the read end of the queue, a
qualifier of FROMQ is displayed on the CEMT INQUIRE UOWENQ screen. If
the task is enqueued against the write end of the queue, a qualifier of TOQ
is displayed on the CEMT INQUIRE UOWENQ screen.
If you want to delete a queue, both the read and the write enqueues must be
obtained. No task may, therefore, read or write to a queue while a delete operation
is in progress. A delete cannot proceed until any task currently reading has
completed its read or any task writing has committed its changes.
In general, a wait on a resource type of ENQUEUE should not last for long unless
the task owning the enqueue has been delayed. If the UOW that owns the enqueue
has suffered an indoubt failure, the UOW is shunted. If the queue accessed by this
UOW is defined as WAIT=YES and WAITACTION=QUEUE, the wait can last for a
long period of time. To deduce if an indoubt failure has occurred:
v Issue a CEMT INQUIRE UOWENQ command to display the name of the
enqueue owner.
v Issue a CEMT INQUIRE UOW command to see if the UOW is shunted.
In most cases, the suspended task will not have to wait long. A lengthy wait can
occur if the task owning the write enqueue suffers from an indoubt failure (which
causes the associated UOW to be shunted), and the queue is defined with the
WAIT=YES and WAITACTION=QUEUE attributes.
If you do not want to wait for data to be committed to the queue, code
NOSUSPEND on the READQ TD request. QBUSY is returned to the application
and the task does not wait.
Tasks are only likely to wait in this way in a heavily loaded system.
Resource type Any_MRCB: When a transient data I/O buffer has been acquired
for a task, a VSAM string must be obtained. If all the VSAM strings available for
transient data processing are in use, the task is suspended on resource type
Any_MRCB, with a resource name equal to the intrapartition queue name.
The reason for this type of wait is best illustrated by example, as follows:
1. Task #1 issues a transient data request that requires access to an intrapartition
queue. Before the request can be serviced, task #1 must be assigned a
transient data I/O buffer that is not currently being used by any other task.
I/O buffers each contain a copy of a control interval (CI) from a data set. Each
CI contains records that correspond to elements in an intrapartition queue. A
search is made to see if the CI required for task #1 is already in one of the I/O
buffers. If it is, that I/O buffer can be used to service the request made by task
#1, and no VSAM I/O is involved. If it is not, task #1 is allocated any buffer, so
the required CI can be read in. The current contents of the buffer is overwritten.
Loader waits
A task is suspended by the loader domain if it has requested a program load and
another task is already loading that program. Once the load in progress is
complete, the suspended task is resumed very quickly and the wait is unlikely to be
detected.
Note that the loader does not suspend a task while a program is loaded if it is the
first one to ask for that program.
If the requested program is not loaded quickly, the reasons for the wait need to be
investigated. The possible reasons for the wait, and the ways you should
investigate them are:
1. The system could be short on storage (SOS), so only system tasks can be
dispatched.
To check if the system is short on storage use the CEMT transaction, submitting
CEMT I SYS SOSSTATUS. To see if SOS has been reached too often, examine
the job log, check the run statistics, or submit CEMT I DSAS. If SOS has been
reached too often, take steps to relieve the storage constraints. For guidance
about this, see the CICS Performance Guide.
2. There could be an I/O error on a library.
Check for messages that might indicate this. If you find one, investigate the
reason why the I/O error occurred.
3. There could be an error within MVS.
Has there been any sort of message to indicate this? If so, it is likely that you
need to refer the problem to the IBM Support Center.
Enqueue waits
A task is suspended by the enqueue domain if it requests access to a resource on
which another task already holds an enqueue (lock). Do not use the EXEC CICS
ENQ command for recoverable resources.
There are two ways in which you can discover the owner of the enqueue that the
task is waiting on:
v Use the CEMT INQUIRE UOWENQ command. For an example of how to use
this command to discover the owner of an enqueue, see page 131. For definitive
information about CEMT INQUIRE UOWENQ, see the CICS Supplied
Transactions manual.
To investigate enqueue waits on these resources, you can use the NQ section of a
system dump. (You can use a system dump to investigate enqueue waits on other
types of resource, but you may find the INQUIRE UOWENQ command more
convenient.)
CICS maintains a separate enqueue pool for each type of resource that can be
enqueued upon. To produce a summary of each enqueue pool, specify '1' on the
NQ dump formatting keyword (dump formatting keywords are described on page
282). Figure 10 on page 117 shows an example summary for the transient data
enqueue (TDNQ) pool.
*NOTE: These values were reset at 15.44.39 (the last statistics interval collection)
OWNER / WAITER
NQEA Tran Tran Lifetime Hash
Enqueue Name Len Sta Address Id Num Local Uowid Uow Tsk Indx
------------------------------ --- --- -------- ---- ----- ---------------- --- --- ----
Q007TOQ 9 Act 052C4580 TDWR 00356 A8EBC70A53A4BC82 1 0 13
Q002FROMQ 9 Act 053D0880 TDRD 00435 A8EBD91A57D9B7D2 2 0 24
Waiter : 0540BBC0 TDRD 00467 A8EBDAC692BB7C10 0 1 24
Waiter : 0537CE70 TDDL 00512 A8EBDAE6FF0B56F2 1 0 24
Q007FROMQ 9 Act 0540CC80 ENQY 00217 A8EBB7FE23067C44 0 1 51
Waiter : 0538F320 ENQY 00265 A8EBBF0846C00FC0 0 1 51
Waiter : 0518C5C0 ENQY 00322 A8EBC393B90C66D8 0 1 51
Q002TOQ 9 Ret 0520B260 ---- ----- A8EBD82AFDA4CD82 1 0 53
Q009FROMQ 9 Act 0540A140 TDRD 00366 A8EBC84D3FF80250 1 0 62
Figure 10. Example system dump, showing summary information for the TDNQ enqueue pool
In the table at the bottom of Figure 10, each enqueue in the pool appears on a new
line. If the enqueue has waiters, they are displayed in order on subsequent lines.
Waiters are identified by the string ‘Waiter’. The meanings of the table headings
are:
Enqueue Name
The string that has been enqueued upon. Normally, up to 30 characters of
the name are displayed; however, the summary reports for file control and
address enqueue pools format the enqueue name differently:
v File control uses six enqueue pools for its various types of lock. Each
enqueue contains the address of a control block (for example, DSNB,
FCTE) in its first four bytes. If the enqueue is a record lock, this is
followed by the record identifier.
Depending upon the type of the data set or file, the remainder of the
enqueue name could, for example, be an RRN in an RRDS, or a record
key in a KSDS data set. In the summary, the remainder of the enqueue
name is displayed in both hex and character formats. This takes up two
summary lines instead of one.
v The summary reports for the EXECADDR and KCADDR enqueue pools
display the enqueue name in hexadecimal format. This is because the
enqueue request was made on an address.
Len The length of the enqueue name.
Sta The state that the enqueue is held in. This field contains either:
Act The enqueue is held in active state—that is, other transactions are
allowed to wait on the enqueue.
Ret The enqueue is held in retained state—that is, other transactions
are not allowed to wait on the enqueue. Typically, this is because
the enqueue is owned by a shunted unit of work.
A resource name of EXECADDR indicates that the LENGTH option of the EXEC
CICS ENQ command was omitted—that is, the RESOURCE option supplied the
address of the resource to be enqueued upon.
A resource name of EXECSTRN indicates that the LENGTH option of the EXEC
CICS region ENQ command was specified—that is, the RESOURCE option
supplied the name of the resource to be enqueued upon. (For detailed information
about the EXEC CICS ENQ command, see the CICS Application Programming
Reference.)
A resource name of EXECPLEX indicates that the LENGTH option of the EXEC
CICS sysplex ENQ command was specified—that is, the RESOURCE option
supplied the name of the resource to be enqueued upon. (For detailed information
about the EXEC CICS ENQ command, see the CICS Application Programming
Reference.)
You can use the CEMT INQUIRE UOWENQ command to discover the owner of the
enqueue that the suspended task is waiting on providing the owner is on the same
region. This cannot detect owners on other regions. Note that, for EXECADDR-type
waits, to display the address of the resource specified on the EXEC CICS ENQ
command you need to use the hexadecimal display option of CEMT.
The implications of waits on any of these file control resource types are dealt with in
the sections that follow.
Waiting on this resource can occur only for a file defined to access a coupling
facility data table.
Waiting on this resource can occur only for a file defined to access a coupling
facility data table.
Waiting on this resource can occur only for files defined to access a coupling facility
data table, and only for record access requests that could potentially require a lock.
Consider increasing the numbers of these buffers if you find that tasks are
frequently having to wait on this resource type.
If there are insufficient data and index buffers for a single task, the task is
suspended indefinitely. This might happen unexpectedly if you have a base cluster
and one or more paths in the upgrade set, and your application references only the
base. VSAM upgrades the paths whenever changes are made to the base. There
could then be too few buffers defined in the LSRPOOL for both base and paths.
Waiting on this resource can occur only for files accessed in non-RLS mode.
If the request is to quiesce a data set, CICS is waiting for other CICS regions that
access the data set to respond to the quiesce request.
Waits on this type of resource can occur only for files accessed in RLS mode.
This is a transient condition. CICS waits for all current update operations for this
VSAM data set to complete and retries the request twice. If the error continues after
the request is retried, CICS assumes that there is a genuine error and returns a
response of ILLOGIC to the application. Since ILLOGIC is a response to all
unexpected VSAM errors, CICS also returns the VSAM response and reason codes
(X'0890') in bytes 2 and 3 of EIBRCODE. These identify the cause of the ILLOGIC
response.
Waiting on this resource can occur only for files accessed in non-RLS mode.
Only one task at a time waits on FCFSWAIT. If any other tasks attempt to change
the state of the same file, they are suspended on resource type ENQUEUE. See
“Task control waits” on page 95.
Waiting on this resource can occur for files accessed in both RLS and non-RLS
mode.
A wait on resource type FCIOWAIT occurs when the exclusive control conflict is
deferred internally by VSAM and not returned as an error condition to CICS. An
example of this is when a request against an LSR file is made for exclusive control
of a control interval (for example, by WRITE or READ UPDATE) and either this task
or another task already holds shared control of this control interval (for example, by
STARTBR).
Waiting on this resource can occur only for files accessed in non-RLS mode.
Because this wait occurs during CICS initialization, you should not be able to see a
task waiting on this resource.
For non-RLS mode, the number of strings defined for a VSAM data set (STRINGS
parameter in the FILE resource definition) determines how many tasks can use the
data set concurrently. STRINGS can have a value in the range 1–255. For RLS
mode, strings are automatically allocated as needed up to a maximum of 1024.
When all the strings are in use, any other task wanting to access the data set must
wait until a string has been released.
If tasks are being caused to wait unduly for strings, consider whether you can
increase the value of STRINGS, or change the programming logic so that strings
are released more quickly.
An example of programming logic that can hold onto strings (and other VSAM
resources) for too long is when a conversational transaction issues a STARTBR or
READNEXT and then enters a wait for terminal input without issuing an ENDBR.
The browse remains active until the ENDBR, and the VSAM strings and buffers are
retained over the terminal wait. Also, for an LSR file, the transaction continues to
hold shared control of the control interval and causes transactions that attempt to
update records in the same control interval to wait.
Waiting on this resource can occur for files accessed in both RLS and non-RLS
mode.
You do not see a task waiting on this resource type, because this wait occurs
during CICS initialization.
Waits on this resource type can occur for files accessed in both RLS and non-RLS
mode.
You do not see a task waiting on this resource type, because this wait occurs
during CICS initialization.
Waiting on this resource can occur for files accessed in both RLS and non-RLS
mode.
The drain is carried out by the system task CSFR. This should normally complete
without problems, although it may take some time if there is a large number of files
to be closed. If a task is waiting on FCRDWAIT for a considerable length of time,
you should check whether the CSFR task is itself in a wait and therefore failing to
complete.
Because this wait occurs during CICS initialization, you should not be able to see a
task waiting on this resource.
A wait on resource type FCRVWAIT occurs when conflicts over shared or exclusive
locks are deferred internally by VSAM and not returned as an error condition to
CICS. Conflicts that can cause an FCRVWAIT wait are:
v A task issues a file control READ UPDATE request for a record, for which:
– Another task already holds an exclusive lock
– One or more tasks hold a shared lock.
v A task issues a file control READ request with CONSISTENT or REPEATABLE
integrity for a record, for which:
– Another task already holds an exclusive lock.
– Another task is waiting for an exclusive lock because one or more tasks may
already have a shared lock, or another task has an exclusive lock.
Waits on FCTISUSP should not be prolonged, and if your task stays suspended on
this resource type, it could indicate any of the following:
v There could be a system-wide problem. CICS could have stopped running, or it
might be running slowly. Turn to “Chapter 2. Classifying the problem” on page 7
for advice if you suspect this.
v There could be a performance problem. Guidance about dealing with
performance problems is given in “Chapter 8. Dealing with performance
problems” on page 159.
v The logic of your applications might need changing, so that tasks do not retain
VSAM transaction IDs for too long. If the task does other processing during the
session, perhaps even involving input from an operator, code to release the
VSAM transaction ID should be included each time.
Waiting on this resource can occur only for files accessed in non-RLS mode.
If you find that exclusive control conflicts occur too often in your system, consider
changing the programming logic so that applications are less likely to have
exclusive control for long periods.
Waiting on this resource can occur only for files accessed in non-RLS mode.
Similarly, a task could be made to wait on another task that has exclusive or shared
control of a VSAM control interval. If this second task was, itself, waiting for
exclusive control of a resource of which the first task has exclusive or shared
control, then both tasks would be deadlocked.
A task that is abended with abend code AFCF would have been waiting for
exclusive control of a VSAM control interval of which another task has shared or
exclusive control.
A task that is abended with abend code AFCG would have been waiting for
exclusive control of a VSAM control interval of which it has shared control.
See the CICS Messages and Codes manual for more information about these
abend codes.
To resolve the problem, you must determine which program caused the potential
deadlock. Find out which programs are associated with the abended task, and
attempt to find the one in error. It is likely to be one that provides successive
browse and update facilities. When you have found the programs associated with
the task, turn to “How tasks can become deadlocked waiting for exclusive control”
for guidance about finding how the error might have occurred.
How tasks can become deadlocked waiting for exclusive control: Tasks can
become deadlocked waiting for exclusive control of a CI only when they have
shared control of the CI and then attempt to get exclusive control without
relinquishing shared control first. This can only occur for VSAM shared resource
data sets accessed in non-RLS mode.
For the deadlock to occur, a transaction must first issue a VSAM READ
SEQUENTIAL request via EXEC CICS STARTBR. This is a VSAM “shared control”
operation. It must then issue some VSAM request requiring exclusive control of the
CI without first ending the shared control operation.
This causes no problems. The next command at first acquires shared control while
the record is read into “input-area”. When an attempt is subsequently made to get
exclusive control, deadlock occurs because the task that wants exclusive control is
also the task that is preventing it from being acquired.
EXEC CICS READ
FILE(myfile)
INTO(input-area)
RIDFLD(rid-area)
UPDATE
The following sequence of commands would not cause deadlock to occur, because
the transaction relinquishes its shared control of the CI by ending the browse before
attempting to get exclusive control of it.
The next command initially causes shared control to be acquired. The record is
read into “input-area”, and then exclusive control is acquired in place of shared
control.
EXEC CICS READ
FILE(myfile)
INTO(input-area)
RIDFLD(rid-area)
UPDATE
The transaction now resumes. Exclusive control is relinquished following the next
REWRITE or UNLOCK command on file “myfile”.
For general information about enqueue waits, see “Enqueue waits” on page 115.
If transactions are commonly made to wait for this reason, you should review the
programming logic of your applications to see if the record-locking time can be
minimized.
Note that CICS only locks a record for update. Other transactions are allowed to
read the record, and this presents a potential read integrity exposure. Thus, a
transaction might read a record after an update has been made, but before the
updating transaction has reached its syncpoint. If the reading transaction takes
action based on the value of the record, the action is incorrect if the record has to
be backed out.
There is some more information about read integrity in “Chapter 9. Dealing with
incorrect output” on page 169.
Neither BDAM nor user-maintained data tables use the “control interval” concept.
When a task reads a record for update, the record is locked so that concurrent
changes cannot be made by two transactions. If the file or data table is recoverable,
the lock is released at the end of the current unit of work. If the file or data table is
not recoverable, the lock is released on completion of the REWRITE or UNLOCK
operation.
If another transaction tries to write a record in the locked key range, or delete the
record at the end of the range, it is suspended until the range lock is released. The
lock is released when the transaction holding it issues a syncpoint, ends the
mass-insert operation by issuing an UNLOCK, or changes to a different range.
When a VSAM data set is opened in load mode, only one request can be issued at
a time. If a transaction issues a WRITE request while another transaction’s WRITE
is in progress, it is suspended until the first WRITE completes.
For integrity reasons, WRITE requests to recoverable ESDS data sets must be
serialized. When a transaction issues such a request, it holds the ESDS write lock
for the time it takes to log the request, obtain a record lock, and write the data set
record. If another transaction issues a WRITE request during this period, it is
suspended until the ESDS lock is released. The lock is normally released when the
WRITE completes, but may be held until syncpoint if the WRITE fails.
When loading a user-maintained data table from its source data set, this lock is
used to serialize loading with application READ requests.
Enqueue deadlocks between tasks occur when each of two transactions (say, A and
B) needs an exclusive lock on a resource that the other holds already. Transaction
A waits for transaction B to release the resource. However, if transaction B cannot
release the resource because it, in turn, is enqueued on a resource held by
transaction A, the two transactions are deadlocked. Further transactions may then
queue, enqueued on the resources held by transactions A and B.
You can use CEMT online to identify deadlocked transactions, and identify the
resources they hold.
The CEMT INQUIRE UOWENQ command displays information about the owners of
all enqueues held. More importantly, for deadlock diagnosis purposes, it displays
information about the tasks waiting for the enqueues. Note that CEMT INQUIRE
If you enter CEMT INQUIRE TASK at a different terminal at this time, a display
similar to the following might appear:
INQUIRE TASK
STATUS: RESULTS - OVERTYPE TO MODIFY
Tas(0000025) Tra(CEMT) Fac(T773) Run Ter Pri( 255 )
Sta(TO) Use(CICSUSER) Uow(AA8E9505458D8C01)
Tas(0000028) Tra(TDUP) Fac(T774) Sus Ter Pri( 001 )
Sta(TO) Use(CICSUSER) Uow(AA8E9505458D8C01) Hty(ZCIOWAIT) Hva(DFHZARQ1)
Tas(0000032) Tra(FUPD) Fac(T775) Sus Ter Pri( 001 )
Sta(TO) Use(CICSUSER) Uow(AA8E950545DAC004) Hty(ENQUEUE ) Hva(FCDSRECD)
Tas(0000035) Tra(FUPD) Fac(T784) Sus Ter Pri( 001 )
Sta(TO) Use(CICSUSER) Uow(AA8E950545DBC357) Hty(ENQUEUE ) Hva(FCDSRECD)
Tas(0000039) Tra(FUPD) Fac(T778) Sus Ter Pri( 001 )
Sta(TO) Use(CICSUSER) Uow(AA8E97FE9592F403) Hty(ENQUEUE ) Hva(FCDSRECD)
Tas(0000042) Tra(FUP2) Fac(T783) Sus Ter Pri( 001 )
Sta(TO) Use(CICSUSER) Uow(AA8E97FE9592F403) Hty(ENQUEUE ) Hva(FCDSRECD)
Task 32 is waiting on an enqueue (Hty = ENQUEUE). You can also see that the
task is waiting for a lock on a data set record (Hva = FCDSRECD). But, at this
stage, you cannot tell which (if any) task has control of this resource.
If you now enter CEMT INQUIRE UOWENQ at the same terminal, you can see the
enqueues held in the system - you can see which tasks own which resources and
which tasks are waiting for those resources.
INQUIRE UOWENQ
STATUS: RESULTS
Uow(AA8E9505458D8C01) Tra(CEMT) Tas(0000025) Act Exe Own
Uow(AA8E9505458D8C01) Tra(TDUP) Tas(0000028) Act Tdq Own
Uow(AA8E950545DAC004) Tra(FUPD) Tas(0000032) Act Dat Own
Uow(AA8E950545DBC357) Tra(FUPD) Tas(0000035) Act Dat Wai
Uow(AA8E97FE9592F403) Tra(FUP2) Tas(0000039) Act Dat Wai
Uow(AA8E9505458D8C01) Tra(TSUP) Tas(0000034) Ret Tsq Own
Uow(AA8E97FE9592F403) Tra(FUP2) Tas(0000039) Act Dat Own
Uow(AA8E950545DAC004) Tra(FUPD) Tas(0000032) Act Dat Wai
Uow(AA8E97FE9592F403) Tra(FUPD) Tas(0000042) Act Dat Own
Figure 12. CEMT INQUIRE UOWENQ shows the owners of and waiters on resources
You can clarify this display in a busy system by displaying only those resources that
the task you are interested in owns and waits for. This is called filtering. You add a
filter to the end of the INQUIRE UOWENQ command: CEMT INQUIRE UOWENQ
TASK(32).
You can now see that task 32 owns one enqueue but is also waiting for another.
Expanding the second entry shows the enqueue that task 32 is waiting for:
So now you need to investigate why task 32 is waiting on the enqueue detailed in
the second expanded entry. You need to find out which task owns this enqueue and
why it is holding it for such a long time. You can do this by filtering the CEMT
INQUIRE UOWENQ command with the RESOURCE and QUALIFIER options.
Enter CEMT INQUIRE UOWENQ RESOURCE(INDX.CICS610.ACIXFILE)
QUALIFIER(SMITH) This shows the task that owns the enqueue that is being
waited on.
This shows you that another task, task 39, owns the enqueue that task 32 is waiting
INQUIRE UOWENQ RESOURCE(INDX.CICS610.ACIXFILE) QUALIFIER(SMITH)
STATUS: RESULTS
Uow(AA8E97FE9592F403) Tra(FUP2) Tas(0000039) Act Dat Own
Uow(AA8E950545DAC004) Tra(FUPD) Tas(0000032) Act Dat Wai
on. In order to find out why task 39 is holding this enqueue, filter the CEMT
command again for task 39. Enter CEMT INQUIRE UOWENQ TASK(39).
This shows you that task 39 is also waiting for an enqueue. If you expand the entry
INQUIRE UOWENQ TASK(39)
STATUS: RESULTS
Uow(AA8E97FE9592F403) Tra(FUP2) Tas(0000039) Act Dat Wai
Uow(AA8E97FE9592F403) Tra(FUP2) Tas(0000039) Act Dat Own
which indicates the waiting state, you may see a display similar to the following:
This shows you that task 39 is waiting for the enqueue on record “SMITH” in the
ACCT.CICS610.ACCTFILE data set. This is the enqueue that task 32 owns. You
can now see that the deadlock is between tasks 32 and 39.
If you filter by the RESOURCE and QUALIFIER of this enqueue, you can confirm
that this is the case. This also shows that task 35 also waits on the enqueue owned
by task 32.
You are now in a position of knowing which transaction(s) to cancel and investigate
INQUIRE UOWENQ RESOURCE(ACCT.CICS610.ACCTFILE) QUALIFIER(SMITH)
STATUS: RESULTS
Uow(AA8E950545DAC004) Tra(FUPD) Tas(0000032) Act Dat Own
Uow(AA8E950545DBC357) Tra(FUPD) Tas(0000035) Act Dat Wai
Uow(AA8E97FE9592F403) Tra(FUP2) Tas(0000039) Act Dat Wai
further.
You can also use the EXEC CICS INQUIRE UOWENQ command or the EXEC
CICS INQUIRE ENQ command in your applications. These returns all the
information that is availableunder CEMT INQUIRE UOWENQ. If you wish to
automate deadlock detection and resolution, these commands are of great benefit.
If a CICS task fails, the NQ domain releases all MVS ENQs held on behalf of that
CICS task
If a CICS system fails, MVS releases all MVS ENQs owned by that CICS region.
This applies even if the reason for the CICS system failure was an MVS or CEC
failure.
When there is a rogue task with enqueues held, which hangs or spins on the spot
(but not subject to runaway), the entire region can halt. CPSM tries to assist in the
If, in the course of your preliminary investigations, you find that the task is waiting
because the terminal where it is due to start is unavailable, turn to “Terminal waits”
on page 101.
v A terminal task that should have been initiated with an EXEC CICS START
command did not start when you expected it to. CEMT INQ TASK does not
recognize the task, because it has not yet been attached.
One approach is to identify the terminal where the subject task should have
started, and see if that terminal is, for some reason, unavailable. You can use
CEMT INQ TERMINAL to find the status of the terminal.
v You have found that a task is waiting on resource type ICGTWAIT. This means
that the task has issued an EXEC CICS RETRIEVE WAIT command, and the
data to be retrieved is, for some reason, not available. The resource name gives
you the name of the terminal running the task in the ICGTWAIT wait and
therefore the target TERMID for other tasks issuing EXEC CICS START
commands to supply more data. If there are no tasks in the system that would
issue START commands for this TERMID, you need to determine whether this is
reasonable. If there are such tasks in the system, check to see why they are not
issuing the required START commands. They might, for example, be waiting for
terminal input.
Look, too, at the deadlock time-out interval (DTIMOUT) and the system purge
value (SPURGE) for the task issuing the EXEC CICS RETRIEVE WAIT
command. If there is no DTIMOUT value or SPURGE=NO has been specified,
the task will wait indefinitely for the data.
Note: The task waiting on resource ICGTWAIT might not be the one that you
first set out to investigate. Any AID task scheduled to start at the same
terminal cannot do so until the current task has terminated.
If none of the simple checks outlined here help you to solve the problem, read the
next section.
First, locate field CSATODTU in the CSA. Make a note of the value there, which is
the current CICS time of day in internal ‘timer units’. Now locate the TCA for your
task, and read the value of field TCAICEAD. This gives you the address of the
interval control element for your task. Use this information to find the ICE (interval
control element) for the task, and look at field ICEXTOD. Make a note of the value
there.
If ICEXTOD is greater than CSATODTU, the ICE has not yet reached the expiry
time. These are the possible explanations:
v Your task either did not make the DELAY request you expected, or the interval
specified was longer than intended. This could indicate a user error. Check the
code of the transaction issuing the request to make sure it is correct.
v Your task’s delay request was not executed correctly. This might indicate an error
within CICS code, or a corrupted control block.
If ICEXTOD is equal to CSATODTU (very unlikely), you probably took the system
dump just as the interval was about to expire. In such a case, attempt to re-create
the problem, take another system dump, and compare the values again.
If ICEXTOD is less than CSATODTU, the ICE has already expired. The associated
task should have resumed. This indicates that some area of storage might have
been corrupted, or there is an error within CICS code.
By their nature, interval control waits can be long, so select auxiliary trace as the
destination, because you can specify large trace data sets for auxiliary trace.
However, the data sets do not have to be large enough to record tracing for the
whole interval specified when you first detected the problem. That is because the
error is likely to be reproducible when you specify a shorter interval, if it is
reproducible at all. For example, if the error was detected when an interval of 20
seconds was specified, try to reproduce it specifying an interval of 1 second.
As far as tracing selectivity is concerned, you need to capture level-2 trace entries
made by dispatcher domain, timer domain, and interval control program. Use the
CETR transaction to set up the following tracing options:
1. Specify special tracing for the level-2 trace points for components DS
(dispatcher domain), TI (timer domain), and IC (interval control program).
2. Select special tracing for the task causing the problem, by specifying special
tracing both for the transaction and for the terminal where it is to be run.
3. Set the master system trace flag off, to turn off all standard tracing. This helps
minimize the number of trace entries not connected with the problem.
4. Make sure that auxiliary tracing is active, then set the transaction running. When
the problem appears, format the auxiliary trace data set and either print it or
view it online.
The sort of trace entries that you can expect in normal operation are shown in the
figures that follow. They show the flow of data and control following execution of the
command EXEC CICS DELAY INTERVAL(000003). A similar set of trace entries
would be obtained if TIME had been specified instead of INTERVAL, because TIME
values are converted to corresponding INTERVAL values before timer domain is
called.
Figure 20 shows the first two entries that you get following execution of the EXEC
CICS DELAY INTERVAL(000003) command.
AP 00E1 EIP ENTRY DELAY REQ(0004) FIELD-A( 0034BD70 ....) FIELD-B(08001004 ....)
TASK-00163 KE_NUM-0007 TCB-009F3338 RET-8413F43E TIME-16:31:58.0431533750 INTERVAL-00.0000166250 =000602=
AP 00F3 ICP ENTRY WAIT REQ(2003) FIELD-A(0000003C ....) FIELD-B(00000000 ....)
TASK-00163 KE_NUM-0007 TCB-009F3338 RET-84760B88 TIME-16:31:58.0432681250 INTERVAL-00.0000370000 =000605=
Figure 20. Trace entries following EXEC CICS DELAY INTERVAL(000003) invocation
Notes:
1. Trace point AP 00E1 is on ENTRY to the EIP DELAY routine. The function is
stated in the trace header, and the fact that this trace is made on ENTRY can
be deduced from the value shown in the request field, REQ(0004).
The rightmost two bytes of FIELD B give the EIBFN value, in this case X'1004'.
This shows that this is an interval control DELAY request.
The value shown against TASK is the trace task number, and it is unique to the
task while the task is in the system. Its purpose is to show which trace entries
relate to which tasks. The task number in this example is 00163. As long as the
task is in the system, and either running or suspended, trace entries having this
task number always relate to it. Use the task number for your task to identify the
trace entries associated with it.
Look next for an entry with point ID DS 0004 showing your task being suspended,
as in Figure 21. You might see TI domain trace entries preceding it that show entry
and exit for FUNCTION(REQUEST_NOTIFY_INTERVAL), but these do not always
appear.
There might also be some intervening entries, but they are unlikely to be of
relevance to the problem.
Figure 21. Trace entries showing interval calculation and task suspension
Notes:
1. Trace point TI 0100, if shown, is on ENTRY to the
REQUEST_NOTIFY_INTERVAL function of timer domain. This is stated
explicitly in the trace header.
The value shown in the header for STCK_INTERVAL is derived from the
machine store clock value calculated for the DELAY interval specified on the
EXEC CICS DELAY command. You can find out how store clock values are
related to times in hours, minutes, and seconds from the ESA/370 Principles of
Operation manual.
If you do the calculation, you find that the value shown is not exactly equal to
the interval you specified. An extra microsecond is added, to account for the
case where the interval is specified as 0.
In this example, 3 seconds is exactly equal to a store clock interval of
X'00000002DC6C0000'. You can see that the actual store clock value is quoted
in the trace entry as X'00000002DC6C1000', which is 3 seconds plus 1
microsecond.
The TIME field of the trace entry shows the time at which the entry was made,
in the format hh:mm:ss. The value in this example (ignoring the fractions of a
second) is 16:31:58. It follows that the task is due to be resumed when the time
is 16:32:01, because the interval is 3 seconds.
Next, get some trace entries recording system activity during the period when your
task is suspended. There are likely to be relatively few at the level of tracing detail
you have specified, but you need to look further on in the trace to find the next
entries of interest.
Add 3 seconds (or whatever interval you specified) to the time shown on the last
trace entry you looked at, and turn forward to the trace entries made at around that
time. Now look for an entry made from trace point DS 0004. This does not show
the task number for your task, but it does show its suspend token. When you have
found it, go back one entry. You should find there a trace entry made from trace
point AP F322. This and the following two trace entries of interest are shown in
Figure 22.
Notes:
1. Trace point AP F322 is used to report that system task APTIX has been
resumed. APTIX has the job of “waking up” your task on expiration of the
specified interval.
The task number for APTIX is, in this case, X'00006', and this value is shown on
the trace entry.
2. Trace point DS 0004 is on entry to the dispatcher SUSPEND/RESUME
interface. This function is stated explicitly in the header.
TASK-00006 indicates that the trace entry is for system task APTIX.
Now look forward in the trace, and locate a trace entry made from trace point
AP 00F3 and showing your task number. This and the next entry conclude the
DELAY request for your task. They are shown in Figure 23.
Figure 23. Trace entries showing satisfactory conclusion of the DELAY request
Notes:
1. Trace point AP 00F3 is on EXIT from interval control program. Field REQ(0005)
shows that this is so, and it also shows that the response was normal. Anything
other than a normal response would result in a value other than X'00' for the
first byte of the REQ field.
2. Trace point AP 00E1 is on EXIT from the EXEC interface program. This is
shown by bits 0–3 of the second byte of the REQ value, X'F4'.
The values shown for FIELD A and FIELD B show that no exception condition
was detected.
That is the end of the DELAY processing, and the task that was suspended should
have been resumed.
When you look at your own trace table, be concerned principally with finding the
point at which the processing went wrong. Also, watch for bad parameters. If you do
find one, it could mean that an application has a coding error, or some field holding
a parameter has been overlaid, or an error has occurred in CICS code.
Checking your application code is the easiest option you have. If you find that it is
correct and you suspect a storage violation, see “Chapter 10. Dealing with storage
violations” on page 193. If you think the error is in CICS code, contact the IBM
Support Center.
A system task that issued a takeover request to CAVM waits on the ECB
WCSTCECB in the CAVM static control block (DFHWCGPS) until CAVM has
decided to accept or reject the request. The DFHKC TYPE=WAIT and DCI=SINGLE
requests are issued in DFHWSRTR. The CAVM TCB posts WCSTCECB in either
DFHWSTKV (the normal case) or DFHWSSOF (CAVM failure).
The following ECBs each represent an event. The ECBs are located in the static
storage for DFHXRP. The ECBs and the events are:
v XRSTIECB—the CAVM has initiated a takeover.
v XRSIAECB—the alternate system is now the incipient active system.
v XRSTCECB—the active system is known to have terminated.
v XRSSSECB—the time-of-day clock is synchronized with active system sign off.
v XRSSTECB—the time-of-day clock is synchronized with active system
termination.
XRSTIECB
This ECB is posted by DFHXRA, following a successful call to the CAVM to initiate
takeover. Once the ECB has been posted, DFHXRA attaches a system transaction
to initiate the switch of terminals with backup sessions. DFHXRA is called from
either the surveillance task (DFHXRSP), or the console communication task
(DFHXRCP). No tasks wait for XRSTIECB to be posted.
XRSIAECB
The XRSIAEB ECB is posted by DFHXRA, following notification by the CAVM that
an alternate system is now the incipient active system. DFHXRA is called from the
surveillance task (DFHXRSP). No tasks wait for XRSIAECB to be posted.
XRSTCECB
The XRSTCECB ECB is posted by DFHXRA, following notification by the CAVM
that an active system has terminated. There can be a delay in posting the ECB if:
v An SDUMP is being taken as part of the active system termination process.
v In a 2-CEC environment, the active CEC has failed, and the operator failed to
reply to the messages sent to the console.
DFHXRA is called from the surveillance task (DFHXRSP). Only one task, the
system initialization task (DFHSII1), waits for XRSTCECB to be posted. When the
ECB is posted, DFHSII1 opens the restart data set, for DFHRC use as well as for
DFHCC use, and then calls DFHXRA to post the XRSRAECB.
XRSRAECB
The XRSRAECB ECB is posted by DFHXRA once the restart data set has been
opened, for DFHRC use as well as for DFHCC use. DFHXRA is called from the
system initialization task (DFHSII1). Two tasks wait for XRSRAECB to be posted:
v The transient data recovery task (DFHTDRP) initializes the entry for the CXRF
queue before waiting for XRSRAECB to be posted. When the ECB is posted,
DFHTDRP resumes emergency restart processing.
XRSSSECB
The XRSSSECB ECB is posted by DFHXRA following notification by the CAVM that
the time-of-day clock is synchronized with active sign off. DFHXRA is called from
the surveillance task (DFHXRSP). No tasks wait for XRSSSECB to be posted.
XRSSTECB
The XRSSTECB ECB is posted by DFHXRA, following notification by the CAVM
that the time-of-day clock is synchronized with respect to active system termination.
There may be a delay in posting the ECB if the time indicated by the active system
time-of-day clock is significantly ahead of that indicated by the alternate system
time-of-day clock. DFHXRA is called from the surveillance task (DFHXRSP).
Only the system initialization task, DFHSII1, waits for XRSSTECB to be posted.
You are only likely to find either of the CICS-supplied transactions CEDA or CESN
waiting on a resource type of XRPUTMSG, and only during XRF takeover by the
alternate CICS system. It can indicate either of these conditions:
v Data that is required by the transactions is held on a volume subject to MVS
RESERVE locking, and another job currently has the lock.
v There is an error in the CICS availability manager.
If it seems clear that MVS RESERVE locking is not implicated, refer the problem to
the IBM Support Center.
Note: You cannot get online information about waiting system tasks from CEMT
INQ TASK or EXEC CICS INQUIRE TASK.
If a system task is in a wait state, and there is a system error preventing it from
resuming, contact your IBM Support Center. However, do not assume that there is a
system error unless you have other evidence that the system is malfunctioning.
Other possibilities are:
v Some system tasks are intended to wait for long periods while they wait for work
to do. Module DFHSMSY of storage manager domain, for example, can stay
suspended for minutes, or even hours, in normal operation. Its purpose is to
clean up storage when significant changes occur in the amount being used, and
that might happen only infrequently in a production system running well within its
planned capacity.
v System tasks perform many I/O operations, and they are subject to constraints
like string availability and volume and data set locking. In the case of tape
volumes, the tasks can also be dependent on operator action while new volumes
are mounted.
If, in addition to the waiting system task, you think you have enough evidence that
shows there is a system error, contact your IBM Support Center.
If the Resource Manager abends, then any active CICS FEPI transactions are left
waiting on the FEPI_RQE resource. Because the Resource Manager is absent,
these waits never get posted, so the transactions suspend. You must issue a CEMT
SET TASK FORCEPURGE command to remove these suspended transactions from
the system.
If such a task does remain suspended for a long time after CICS initialization
completes, there is probably an error in CICS—contact your IBM Support Center.
If a task remains suspended for a long time with a resource type of RMUOWOBJ
and a resource name of LOGMOVE, try to discover why the activity keypoint task
(CSKP) is not completing.
If a task remains suspended for a long time with a resource type of RMUOWOBJ
and a resource name of EXISTENC, try to discover why the activity keypoint task
(CSKP) is not completing.
On cold start, loading the GRPLIST definitions from the CSD data set can take
several minutes. For large systems, the delay could be 20 minutes or more while
this takes place. You can tell if this stage of initialization has been reached because
you get this console message:
DFHSI1511 INSTALLING GROUP LIST xxxxxxxx
On warm start, there may be a considerable delay while resource definitions are
being created from the global catalog.
If you find that unexpected delays occur at other times during CICS initialization,
consider the messages that have already been sent to the console and see if they
suggest the reason for the wait. For example, a shortage of storage is one of the
most common causes of stalling, and is always accompanied by a message. The
JCL job log is another useful source of information.
You can find out if this has happened by taking an SDUMP of the CICS region.
Format the dump using the keywords KE and DS, to get the kernel and dispatcher
task summaries.
Consider, too, whether any first-or second-stage program list table (PLT) program
that you have written could be in error. If such a program does not follow the strict
Look first on your MVS console for any messages. Look particularly for messages
indicating that operator intervention is needed, for example to change a tape
volume. The action could be required on behalf of a CICS task, or it could be for
any other program that CICS interfaces with.
If the CPU usage is low, CICS is doing very little work. Some of the possible
reasons are:
v The system definition parameters are not suitable for your system.
v The system is short on storage, and new tasks cannot be started. This situation
is unlikely to last for long unless old tasks cannot, for some reason, be purged.
v The system is at one of the MXT or transaction class limits, and no new tasks
can be attached. In such a case, it is likely that existing tasks are deadlocked,
and for some reason they cannot be timed out.
v There is an exclusive control conflict for a volume.
v There is a problem with the communications access method.
v There is a CICS system error.
The way you can find out if any of these apply to your system is dealt with in the
paragraphs that follow. For some of the investigations, you will need to see a
system dump of the CICS region. If you do not already have one, you can request
one using the MVS console. Make sure that CICS is apparently stalled at the time
you take the dump, because otherwise it will not provide the evidence you need.
Format the dump using the formatting keywords KE and XM, to get the storage
areas for the kernel and the transaction manager.
Are the system definition parameters wrong?: It is possible that the system
definition parameters for your system are causing it to stall, possibly at a critical
loading. Take a look at what has been specified, paying particular attention to these
items:
v The CICS maximum tasks ( MXT) and transaction class (MAXACTIVE) limits. If
these are too low, new tasks could fail to be attached. If you suspect one of
these limits is the cause of the stall, read “Are MXT or transaction class limits
causing the stall?” on page 146 for a way of getting further evidence.
v ICV, the system region exit time. If this is set too high, CICS might relinquish
control to the operating system for longer than intended when it has no work to
do, perhaps giving the impression of a stall.
v ICVR, the runaway task time interval. If this is set too high, a runaway task could
stop other tasks from running for a relatively long time. It can have a value up to
For more details about the choice of these and other system definition parameters,
see the CICS Performance Guide.
Are MXT or transaction class limits causing the stall?: Before new
transactions can be attached for the first time, they must qualify under the MXT and
transaction class limits. In a system that is running normally, tasks run and
terminate and new transactions are attached, even though these limits are reached
occasionally. It is only when tasks can neither complete nor be purged from the
system that CICS can stall as a result of one of these limits being reached.
Look first at the transaction manager summary in the formatted system dump.
Investigate the tasks accepted into the MXT set of tasks to see if they are causing
the problem. XM dump formatting formats the state of MXT and provides a
summary of the TCLASSes and of the transactions waiting for acceptance into each
TCLASS.
Now look at the Enqueue Pool Summary in the NQ section of the dump for a
summary of task enqueues and resources. This section of the dump lists all
enqueues in CICS. Look for any enqueues that have many tasks in a waiting state.
If there are any, look for the unit of work (UOW) for which the enqueue state is
active. Look to see if this UOW is waiting on a resource.
Is there an MVS system logger error?: If you suspect that there may be a
problem with the MVS system logger, see “Log manager waits” on page 94.
Is there a CICS system error?: If you have investigated all the task activity, and
all the other possibilities from the list, and you have still not found an explanation
for the stall, it is possible that there is a CICS system error. Contact the IBM
Support Center with the problem.
If you find that you cannot use the CEMT transaction, it is likely that the system is
already in the second stage of termination. CEMT cannot be used beyond the first
stage of termination.
Note: Even if CEMT is not included in the transaction list table (XLT), you can still
use it in the first stage of termination.
The action to take next depends on whether you can use the CEMT transaction,
and if so, whether or not there are current user tasks.
v If you can use the CEMT transaction:
– If there are user tasks currently in the system, check what they are. A task
may be performing a prolonged termination routine, or it might be waiting on a
resource before it can complete its processing. It is also possible that a task is
waiting for operator intervention.
Determine what type of terminal is associated with the task. If the terminal is a
3270 device, some keyboard input might be expected. If it is a printer, it might
have been powered off or it might have run out of paper.
– If there are no user tasks in the system, it may be that one or more terminals
have not been closed. Use the CEMT transaction to see which terminals are
currently INSERVICE, and then use CEMT SET to place them OUTSERVICE.
If these actions fail, proceed as if you were unable to use the CEMT transaction.
v If you cannot use the CEMT transaction, go to the MVS console or the
NetView® master terminal and display the active sessions. If necessary, close
down the network using the VARY NET,INACT,ID=applid command. This should
enable CICS to resume its termination sequence. If it does not, you might need
to cancel the CICS job. If this does happen, consider whether any PLT program
running in the second quiesce stage could be in error. If such a program did not
If a loop does not terminate, it could be that the termination condition can never
occur, or it might not be tested for, or the conditional branch could erroneously
cause the loop to be executed over again when the condition is met.
This section outlines procedures for finding which programs are involved in a loop
that does not terminate.
If you find that the looping code is in one of your applications, you need to check
through the code to find out which instructions are in error. If it looks as if the error
is in CICS code, you probably need to contact the IBM Support Center.
Some CICS domains can detect loops in their own routines, and let you know if one
is suspected by sending the following message:
The two characters “xx” represent the two-character domain index. If, for example,
monitoring domain had detected the loop, the message number would be
DFHMN0004.
If you see this sort of message repeatedly, contact the IBM Support Center.
Unplanned loops
│
┌───────────────────┴─────────────────────┐
│ │
Detectable by CICS Not detectable by CICS
│ │
┌────────┴────────┐ │
│ │ │
Tight loops Non-yielding loops Yielding loops
CICS can detect some looping tasks by comparing the length of time the tasks
have been running with the runaway time interval, ICVR, that you code in the
system initialization table. If a task runs for longer than the interval you specify,
CICS regards it as “runaway” and causes it to abend with an abend code of AICA.
However, in some cases, CICS requests that are contained in the looping code can
cause the timer to be reset. Not every CICS request can do this; it can only happen
if the request can cause the task to be suspended. Thus, if the looping code
contains such a request, CICS cannot detect that it is looping.
The properties of the different types of loop, and the ways you can investigate
them, are described in the sections that follow.
Note: If you make the ICVR value equal to 0, runaway task detection is disabled.
Runaway tasks can then cause the CICS region to stall, meaning that CICS
must be canceled and brought up again. You might choose to set ICVR to
zero in test systems, because of the wide variation in response times.
However, it is usually more advisable to set ICVR to a large value in test
systems.
A tight loop is one involving a single program, where the same instructions are
executed repeatedly and control is never returned to CICS.
Figure 26 on page 151 shows a tight loop, with an indefinite number of instructions
contained in the loop. None of the instructions returns control to CICS. In the
extreme case, there could be a single instruction in the loop, causing a branch to
itself.
A non-yielding loop is also contained in a single program, but it differs from a tight
loop in that control is returned temporarily from the program to CICS. However, the
CICS routines that are invoked are ones that can neither suspend the program nor
pass control to the dispatcher.2 There is, therefore, no point at which the task can
be suspended, and so the ICVR cannot be reset.
this case, the loop contains only one CICS command, EXEC CICS ASKTIME.
2. The CICS commands that do not cause tasks to wait include (but are not restricted to) ASKTIME, DEQ, ENQ, ENTER
TRACENUM, FREEMAIN, HANDLE, RELEASE, TRACE ON/OFF. Whether a command allows the ICVR to be reset might also
depend on other factors. For instance, a FREEMAIN might reset the ICVR if the storage lock is held. A READ might also not wait if
the desired record is already in a VSAM buffer.
If you have a transaction that repeatedly abends with an abend code of AICA, first
make sure the ICVR value has not been set too low. If the value seems reasonable,
read “Investigating loops that cause transactions to abend with abend code AICA”
on page 154 for advice on determining the limits of the loop.
If you have a stalled CICS region, diagnose the problem using the techniques in
“What to do if CICS has stalled” on page 144. Check if the ICVR value has been
set to zero. If it has, change the value and try to cause a transaction to abend with
a code of AICA.
Yielding loops
Yielding loops are characterized by returning control at some point to a CICS
routine that can suspend the looping task. However, the looping task is eventually
resumed, and so the loop continues.
CICS is unable to use the runaway task timer to detect yielding loops, because the
timer is reset whenever the task is suspended. Thus, the runaway task time is
unlikely ever to be exceeded, and so the loop goes undetected by the system.
Figure 30 shows a specific example of a yielding loop within a single program. This
code issues the SUSPEND command, which is always a yielding type of command.
Every time SUSPEND is issued, the dispatcher suspends the task issuing the
request, and sees if any other task of higher priority can run. If no such task is
ready, the program that issued the SUSPEND is resumed.
┌───────────────────────────────────────────────────────────┐
│ PROCEDURE DIVISION. │
│ EXEC CICS │
│ HANDLE CONDITION ERROR(ERROR─EXIT) │
│ ENDFILE(END─MSG) │
│ END─EXEC. │
│ ROUTE─FILE. │
│ EXEC CICS │
│ ROUTE INTERVAL(0) │
│ LIST(TERM─ID) │
│ END─EXEC. │
│ NEW─LINE─ATTRIBUTE. │
│ EXEC CICS │
│ SUSPEND │
│ END─EXEC. │
│ GO TO NEW─LINE─ATTRIBUTE. │
│ MOVE LOW─VALUES TO PRNTAREA. │
│ MOVE DFHBMPNL TO PRNTAREA. │
└───────────────────────────────────────────────────────────┘
You can detect a yielding loop only by circumstantial evidence such as repetitive
output, or excessive use of storage. A fuller description of what to look out for is
given in “Loops” on page 13.
If you suspect that you have a yielding loop, turn to “Investigating loops that are not
detected by CICS” on page 156 for further guidance.
Both a tight loop and a non-yielding loop are characterized by being confined to a
single user program. You should know the identity of the transaction to which the
program belongs, because it is the transaction that abended with code AICA when
the runaway task was detected.
It is also useful to have trace running, as trace can help you to identify the point in
your program where looping started. If you have a non-yielding loop, it can probably
also show you some instructions in the loop.
A tight loop is unlikely to contain many instructions, and you might be able to
capture all the evidence you need from the record of events in the internal trace
table. A non-yielding loop may contain more instructions, depending on the EXEC
CICS commands it contains, but you might still be able to capture the evidence you
need from the record of events in the internal trace table. If you find that it is not big
enough, direct tracing to the auxiliary trace destination instead.
You need to trace CICS system activity selectively, to ensure that most of the data
you obtain is relevant to the problem. Set up the tracing like this:
1. Select level-1 special tracing for AP domain, and for the EXEC interface
program (EI).
2. Select special tracing for just the task that has the loop, and disable tracing for
all other tasks by turning the master system trace flag off.
You can find guidance about setting up these tracing options in “Chapter 15. Using
traces in problem determination” on page 225.
Now start the task, and wait until it abends AICA. Format the CICS system dump
with formatting keywords KE and TR, to get the kernel storage areas and the
internal trace table. (See “Formatting system dumps” on page 280.) You now have
the documentation you need to find the loop.
Now use the kernel task number for the looping task to find its linkage stack. If a
user task is looping, DFHAPLI, a transaction manager program, should be near the
top of the stack. You are likely to find other CICS modules at the top of the stack
If the kernel linkage stack entries suggest that the loop is in your user program, you
next need to identify the loop.
The entries preceding AP 1942 should have been made either just before the loop
was entered (for a tight loop), or within the loop itself (for a non-yielding loop).
Watch in particular for trace entries with the point ID AP 00E1. These are made on
entry to the EXEC interface program (DFHEIP) whenever your program issues an
EXEC CICS command, and again on exit from the EXEC interface program. Field B
gives you the value of EIBFN, which identifies the specific command that was
issued. (For a list of EIBFN values and their meanings, see the CICS User’s
Handbook.)
For trace entries made on exit from DFHEIP, field A gives you the response code
from the request. Look carefully at any response codes—they could provide the
clue to the loop. Has the program been designed to deal with every possible
response from DFHEIP? Could the response code you see explain the loop?
If you see a repeating pattern of trace points for AP 00E1, you have a non-yielding
loop. If you can match the repeating pattern to statements in the source code for
your program, you have identified the limits of the loop.
If you see no repeating pattern of trace points for AP 00E1, it is likely that you have
a tight loop. The last entry for AP 00E1 (if there is one) should have been made
from a point just before the program entered the loop. You might be able to
recognize the point in the program where the request was made, by matching trace
entries with the source code of the program.
If the next instruction address is not within your code, it is of less value for locating
the loop. However, you should attempt to identify the module containing the
instruction, as it is likely to be one that was called during the execution of a CICS
request made within the loop. Use the module index at the end of the formatted
Note: It is possible that the loop was contained entirely within a module owned by
CICS or some other product, and your program was not responsible for it at
all. If you find that the loop is contained within CICS code, contact the IBM
Support Center.
If the PSW does point to a module outside your application program, you need to
find the address of the return point in your program from the contents of register 14
in the appropriate register save area. The return address will lie within the loop, if
the loop is not confined to system code.
When you have located a point within the loop, work through the source code and
try to find the limits of the loop.
A good place to look for clues to loops is immediately before the loop sequence, the
first time it is entered. Occasionally, a request that results in an unexpected return
code can trigger a loop. However, you usually can only see the last entry before the
loop if you have CICS auxiliary or GTF trace running, because the internal trace
table is likely to wrap before the AICA abend occurs.
The nature of the symptoms may indicate which transaction is involved, but you
probably need to use trace to define the limits of the loop.
Use auxiliary trace to capture the trace entries, to ensure that the entire loop is
captured in the trace data. If you use internal trace, there is a danger that
wraparound will prevent you from seeing the whole loop.
Use the CETR transaction to set up the following tracing options. You can use the
transaction dynamically, on the running CICS system. For guidance about using the
CETR transaction, see “Chapter 15. Using traces in problem determination” on
page 225.
1. Select level-1 special tracing for every component, using the CETR transaction.
You need to capture as much trace information for the task as possible,
because you do not yet know what functions are involved in the loop.
2. Set all standard tracing off, by setting the master system trace flag off.
3. Select special tracing for just the task containing the loop.
These steps ensure that you get all level-1 trace points traced for just the task you
suspect of looping, the trace entries being sent to the auxiliary trace destination.
When you have captured the trace data, you need to purge the looping task from
the system. Use the CEMT INQ TASK command to find the number of the task, and
then purge it using either the CEMT SET TASK PURGE or the CEMT SET TASK
FORCEPURGE command. This causes the transaction to abend, and to produce a
transaction dump of the task storage areas.
Note: The use of FORCEPURGE is, in general, not recommended, because it can
cause unpredictable system problems. For example, it causes task storage
areas to be released, including I/O areas, without notifying any components
that might be accessing them. If the FORCEPURGEd task was waiting for
input, such an area might be written to after it is released. The storage might
even be in use by another task when the input occurs.
The trace data and the program listings should enable you to identify the limits of
the loop. You need the transaction dump to examine the user storage for the
program. The data you find there could provide the evidence you need to explain
why the loop occurred.
Consider also the possibility that you might not be dealing with a loop, and the
symptoms you saw are due to something else—poor application design, for
example.
If you are able to detect a pattern, you should be able to identify the corresponding
pattern of statements in your source code.
Note: The PSW is of no value in locating loops that are not detected by CICS. The
contents of the PSW are unpredictable, and the PSW is not formatted in the
transaction dump for ATCH abends.
CECI and CEBR are also useful for investigating loops. You can, for example, use
them to examine the status of files and queues during the execution of your
program. Programs can react unpredictably if records and queue entries are not
found when these conditions are not tested for and handled accordingly.
If you are only aware that performance is poor, and you have not yet found which of
these is relevant to your system, read “Finding the bottleneck”.
There is a quick reference section at the end of this section (“A summary of
performance bottlenecks, symptoms, and causes” on page 166) that summarizes
bottlenecks, symptoms, and actions that you should take.
Each bottleneck is affected by a different set of system parameters, and you may
find that adjusting the parameters solve the problem. It is useful to determine which
bottleneck is causing your performance problem, so you can find out which
parameters you need to consider.
If performance is particularly poor for any of the tasks in your system, you might be
able to capture useful information about them with CEMT INQ TASK. However,
tasks usually run more quickly than you can inquire on them, even though there
may be a performance problem. You then need to consider using performance class
monitoring or tracing to get the information you need.
Guidance about finding out why tasks take a long time to get an initial attach to the
transaction manager is given in “Why tasks fail to get attached to the transaction
manager” on page 161.
If CEMT INQ TASK returns anything other than this, the task is not waiting to be
attached to the dispatcher. However, consider whether the MXT limit might be
causing the performance problem, even though individual tasks are not being held
up long enough for you to use CEMT INQ TASK on them. In such a case, use
monitoring and tracing to find just how long tasks are waiting to be attached to the
dispatcher.
Guidance about finding whether the MXT limit is to blame for the performance
problem is given in “Is the MXT limit preventing tasks from getting attached?” on
page 162.
Initial dispatch
A task can be attached to the dispatcher, but then take a long time to get an initial
dispatch. In such a case, CEMT INQ TASK returns a status of ‘READY’ for the task.
If you keep getting this response and the task fails to do anything, it is likely that
the task you are inquiring on is not getting its first dispatch.
The delay might be too short for you to use CEMT INQ TASK in this way, but still
long enough to cause a performance problem. In such a case, you need to use
tracing or performance class monitoring for the task, either of which would tell you
how long the task had to wait for an initial attachment to the dispatcher.
If you think your performance problem could be due to tasks taking a long time to
get a first dispatch, read “Why tasks fail to get an initial dispatch” on page 164.
You might be able to use CEMT INQ TASK to show that a task is failing to get
attached because of the MXT or transaction class limits. If you cannot use CEMT
because the task is held up for too short a time, you can look at either the
transaction global statistics, transaction class statistics, or the CICS
performance-class monitoring records. Another option is to use CICS system
tracing.
Using transaction manager statistics: To find out how often the MXT and
transaction class limits are reached, look at the transaction global statistics and
transaction class statistics. If you compare the number of times these limits are
reached with the total number of transactions, you can see whether the values set
for the limits are adversely affecting performance.
To gather statistics relating to the number of times that the MXT or transaction class
limits are reached, you need to use, at the start of the run, the command CEMT
PERFORM STATISTICS RECORD (or your site replacement) with the keywords
TRANSACTION and TRANCLASS.
CEMT PERFORM STATISTICS RECORD [TRANCLASS TRANSACTION]
The statistics are gathered and recorded in the SMF data set. You can format this
data set by using the statistics utility program, DFHSTUP. Please read the
’DFHSTUP’ section in the CICS Operations and Utilities Guide for details on how to
use this facility.
When formatting the SMF data set using DFHSTUP, you may find the following
DFHSTUP control parameters useful:
SELECT APPLID=
COLLECTION TYPE=REQ
TIME START= ,STOP=
DATE START= ,STOP=
See the ’DFHSTUP’ section in the CICS Operations and Utilities Guide for details
on how to code these parameters. If you correctly code these control parameters,
you will avoid the formatting of much information that may well be unnecessary at
this point.
3. For a system task, there may not be enough storage to build the new task. This sort of problem is more likely to occur near peak
system load times.
Consider revising the MXT and transaction class values if the statistics indicate that
they are affecting performance. For guidance about the performance considerations
when you set these limits, see the CICS Performance Guide.
Using CICS monitoring: You can use monitoring information to find out how long
an individual task waits to be attached to the Dispatcher. If you want to summarize
the monitoring data of particular transactions to assess the impact across many
tasks, you can use products such as Service Level Reporter (SLR) or Enterprise
Performance Data Manager/MVS (EPDM/MVS).
For further information on the data produced by CICS monitoring see the CICS
Performance Guide.
Using trace: You can use trace if you want to find out just how long an individual
task waits to be attached to the dispatcher.
If you do not want to do any other tracing, internal trace is probably a suitable
destination for trace entries. Because the task you are interested in is almost
inactive, very few trace entries are generated.
Select special tracing for the transaction associated with the task, and turn off all
standard tracing by setting the master system trace flag off. Define as special trace
points the level-1 trace points for transaction manager (XM), and for the CICS task
controlling the facility that initiates the task, such as terminal control (TC). Make
sure that no other trace points are defined as special. For guidance about setting
up these tracing options, see “Chapter 15. Using traces in problem determination”
on page 225.
When you have selected the options, start tracing to the internal trace table and
attempt to initiate the task. When the task starts, get a system dump with CEMT
PERFORM SNAP. Format the dump using the keyword TR, to get the internal trace
table.
Look for the trace entry showing terminal control calling the transaction manager
with a request to attach the task, and the subsequent trace entry showing the
transaction manager calling dispatcher domain with a request to attach the task.
The time stamps on the two trace entries tell you the time that elapsed between the
two events. That is equal to the time taken for the task to be attached.
You can get evidence that tasks are waiting too long for a first dispatch from
performance class monitoring. If you do find this to be the case, you need to
investigate the reasons for the delay. To calculate the initial dispatch delay incurred
by a task use the following fields from the performance-class monitoring record:
The factors that influence the length of time a task must wait before getting its first
dispatch are:
v The priority of the task
v Whether the system is becoming short on storage.
Priorities of tasks
Normally, the priorities of tasks determine the order in which they are dispatched.
Priorities can have any value in the range 1–255. If your task is getting a first
dispatch (and, possibly, subsequent dispatches) too slowly, you might consider
changing its priority to a higher value.
One other factor affecting the priorities of tasks is the priority aging multiplier,
PRTYAGE, that you code in the system initialization parameters. This determines
the rate at which tasks in the system can have their priorities aged. Altering the
value of PRTYAGE affects the rate at which tasks are dispatched, and you probably
need to experiment to find the best value for your system.
Storage stress conditions are detailed in the storage manager statistics. CICS
attempts to alleviate the situation by releasing programs with no current user, and
by not attaching new tasks. If these actions fail to eliminate storage stress or if the
SOS condition is caused by a suspended GETMAIN, one or both of these
messages is sent to the console:
If you don’t observe the SOS messages, you can find out how many times CICS
has gone SOS from the storage manager statistics (’Times went short on storage’).
You can also get this information from the storage manager domain DSA summary
in a formatted system dump.
Two other conditions are recognized by the dispatcher on the approach to SOS,
namely ‘storage getting short’ and ‘storage critical’. The two conditions affect the
chance of new tasks getting a first dispatch.
From the ‘storage getting short’ point, through ‘storage critical’ and right up to SOS,
the priorities of new user tasks are reduced in proportion to the severity of the
condition 4 . At first, you are not likely to notice the effect, but as ‘storage critical’ is
approached, new tasks might typically be delayed by up to a second before they
are dispatched for the first time.
It is likely that ‘storage getting short’ and ‘storage critical’ occur many times for
every occasion SOS is reached. If you want to see how often these points are
reached, select level-2 tracing for the dispatcher domain and look out for trace point
IDs DS 0038 (‘storage getting short’) and DS 0039 (‘storage critical’). Trace point
DS 0040 shows that storage is OK.
A summary of the effects of ‘storage getting short’, ‘storage critical’, and SOS is
given in Table 26.
Table 26. How storage conditions affect new tasks getting started
State of storage Effects on user tasks
Storage getting short Priority of new user tasks reduced a
little
Storage critical Priority of new user tasks reduced
considerably
The longer the task spends in the non-running state, either ‘ready’ or ‘suspended’,
the greater your perception of performance degradation. In extreme cases, the task
might spend so long in the non-running state that it is apparently waiting indefinitely.
It is not likely to remain ‘ready’ indefinitely without running, but it could spend so
long suspended that you would probably classify the problem as a wait.
The purpose of this section is to deal not with waiting tasks, but instead with tasks
that complete more slowly than they should.
Here are some factors that can affect how long tasks take to complete:
Any task in the system can use resources and not allow other tasks to use them.
Normally, a task with a large time-out interval is likely to hold on to resources longer
than a task with a short time-out interval. Such a task has a greater chance of
preventing other tasks from running. It follows that task time-out intervals should be
chosen with care, to optimize the use of resources by all the tasks that need them.
Other system programs also use the MVS RESERVE mechanism to gain exclusive
control of DASD volumes, making the data sets on those volumes inaccessible to
other regions.
If you notice in particular that tasks making many file accesses take a long time to
complete, check the distribution of the data sets between DASD volumes to see if
volume locking could be the cause of the problem.
Terminal not
available
Remote
system not
available
Priority of
task set too
low
Insufficient
storage
System
under stress,
or near it
SUSPEND / RESUME Tasks take a long time to complete. System
cycle loading high
Task
time-out
interval too
large
CICS data
sets are on
volumes
susceptible
to MVS
RESERVE
locking
For CICS system tracing other than exception traces and CICS VTAM exit traces,
you can inquire on the current destinations and set them to what you want using
the CETR transaction.
Figure 44 on page 243 illustrates what you might see on a CETR screen, and
indicates how you can change the options by overtyping the fields. From that
illustration you can see that, from the options in effect, a normal trace call results in
a trace entry being written to the GTF trace destination. If an exceptional condition
occurred, the corresponding exception trace entry would be made both to the GTF
data set and to the internal trace table, even though the internal trace status is
STOPPED.
© Copyright IBM Corp. 1979, 2001 169
Note that the master system trace flag value only determines whether standard
tracing is to be done for a task (see Figure 42 on page 237). It has no effect on any
other tracing status.
Internal tracing goes to the internal trace table in main storage. The internal trace
table is used as a buffer in which the trace entries are built no matter what the
destination. It, therefore, always contains the most recent trace entries, even if its
status is STOPPED—if at least one of the other trace destinations is currently
STARTED.
Auxiliary tracing goes to one of two data sets, if the auxiliary tracing status is
STARTED. The current data set can be selected from the CETR screen by
overtyping the appropriate field with A or B, as required. What happens when the
data set becomes full is determined by the auxiliary switch status. Make sure that
the switch status is correct for your system, or you might lose the trace entries you
want, either because the data set is full or because they are overwritten.
GTF tracing goes to the GTF trace data set. GTF tracing must be started under
MVS, using the TRACE=USR option, before the trace entry can be written. Note
that if GTF tracing has not been started in this way, the GTF tracing status can be
shown as STARTED on the CETR screen and yet no trace entries are made, and
no error condition reported.
The way in which trace entries are directed to the required destinations is illustrated
in Figure 45 on page 245.
If you are aware of symptoms like these, it is likely that you do not have the right
task tracing options set up. Turn to “You are not getting the correct task tracing” on
page 171 for further guidance.
2. You are getting the wrong amount of data traced, because:
v Tracing is not being done for all the components you want, so you are getting
too little information.
v Tracing is being done for too many components, so you are getting more
information than you want.
v You are not getting the right trace points (level-1 or level-2) traced for some
of the components.
v Tasks are not tracing the component trace points you want. This evidence
suggests CICS component tracing selectivity is at fault.
If your observations fit any of these descriptions, turn to “You are not getting the
correct component tracing” on page 171 for guidance about fixing the problem.
3. The data you want is missing entirely from the trace table.
If you have this sort of problem, turn to “The entries you want are missing from
the trace table” on page 171 for guidance about finding the cause.
You can define whether you want standard or special CICS tracing for specific
transactions, and standard or special tracing for transactions started at specific
terminals. You can also suppress tracing for transactions and terminals that do not
interest you. The type of task tracing that you get (standard or special) depends on
the type of tracing for the corresponding transaction-terminal pair, in the way shown
in Figure 40 on page 236.
You can deduce from the table that it is possible to get standard tracing when a
transaction is initiated at one terminal, and special tracing when it is initiated from
another terminal. This raises the possibility of setting up inappropriate task tracing
options, so the trace entries that interest you—for example, when the transaction is
initiated from a particular terminal—are not made.
First, check that you are only tracing components that interest you. If some other
components are being traced, change the options so they are no longer traced for
standard tracing or for special tracing, as appropriate.
Next, check that the right tracing levels have been defined for standard tracing and
special tracing. Remember that, whenever a task that has standard tracing is
running, the trace points that you have defined as standard for a component are
traced whenever that component is invoked. Similarly, special trace points are
traced whenever special task tracing is being done.
Figure 42 on page 237 illustrates the logic used to determine whether a trace call is
to be made from a trace point.
If you are satisfied that the component tracing selectivity is correct but you are still
getting too much or too little data, read “You are not getting the correct task
tracing”.
The entries you want are missing from the trace table
Read this section if one or more entries you were expecting were missing entirely
from the trace table.
If the trace entry did not appear at the expected time, consider these
possibilities:
v If tracing for some components or some tasks did not appear, you might not have
set up the tracing selectivity correctly. For guidance about checking and
If the options were correct and tracing was running at the right time, but the trace
entries you wanted did not appear, it is likely that the task you were interested in
did not run or did not invoke the CICS components you expected. Examine the
trace carefully in the region in which you expected the task to appear, and attempt
to find why it was not invoked. Remember also that the task tracing options might
not, after all, have been appropriate.
If the earliest trace entry was later than the event that interested you, and
tracing was running at the right time, it is likely that the trace table wrapped round
and earlier entries were overwritten.
Internal trace always wraps when it is full. Try using a bigger trace table, or direct
the trace entries to the auxiliary trace or GTF trace destinations.
Note: Changing the size of the internal trace table during a run causes the data
that was already there to be destroyed. In such a case, the earliest data
would have been recorded after the time when you redefined the table size.
Auxiliary trace switches from one data set to the next when it is full, if the
autoswitch status is NEXT or ALL.
If the autoswitch status is NEXT, the two data sets can fill up but earlier data cannot
be overwritten. Your missing data might be in the initial data set, or the events you
were interested in might have occurred after the data sets were full. In the second
case, you can try increasing the size of the auxiliary trace data sets.
If the autoswitch status is ALL, you might have overwritten the data you wanted.
The initial data set is reused when the second extent is full. Try increasing the size
of the auxiliary trace data sets.
If you cannot find an exception trace entry that you expected, bear in mind that
exception tracing is always done to the internal trace table irrespective of the status
of any other type of tracing. So, if you missed it in your selected trace destination,
try looking in the internal trace table.
The sections that follow give guidance about resolving each of these problems in
turn.
The dump you got did not seem to relate to your CICS region
If you have experienced this problem, it is likely that you have dumped the wrong
CICS region. It should not occur if you are running a single region.
If you invoked the dump from the MVS console using the MVS MODIFY command,
check that you specified the correct job name. It must be the job used to bring up
the CICS region in which you are interested. If you invoked the dump from the
CICS master terminal using CEMT PERFORM SNAP, check that you were using
the master terminal for the correct region. This is more likely to be a problem if you
have a VTAM network, because that allows you to switch a single physical VTAM
terminal between the different CICS regions.
There are, in general, two reasons why dumps might not be taken:
v Dumping was suppressed because of the way the dumping requirements for the
CICS region were defined. The valid ways that dumping can be suppressed are
described in detail in the sections that follow.
v A system error could have prevented a dump from being taken. Some of the
possibilities are:
– No transaction or system dump data sets were available.
– An I/O error occurred on a transaction or a system dump data set.
– The system dump data set was being written to by another region, and the
DURETRY time was exceeded.
You need to find out which of these types of dump suppression apply to your
system before you decide what remedial action to take.
You can inquire whether system dumping has been suppressed globally by using
the EXEC CICS INQUIRE SYSTEM DUMPING system programming command. If
necessary, you can cancel the global suppression of system dumping using EXEC
CICS SET SYSTEM DUMPING with a CVDA value of SYSDUMP.
If an exit program that suppresses system dumping for a particular dump code is
enabled, system dumping is not done for that dump code. This overrides any
system dumping requirement specified for the dump code in the dump table.
The exit program can suppress system dumps only while it is enabled. If you want
the system dumping suppression to be canceled, you can issue an EXEC CICS
DISABLE command for the program. Any system dumping requirements specified in
the dump table then take effect.
You can use EXEC CICS INQUIRE TRANSACTION DUMPING to see whether
dumping has been suppressed for a transaction, and then use the corresponding
SET command to cancel the suppression if necessary.
You can inquire on transaction and system dump code attributes using CEMT INQ
TRDUMPCODE and CEMT INQ SYDUMPCODE, respectively. You must specify the
dump code you are inquiring on.
If you find that the dumping options are not what you want, you can use CEMT SET
TRDUMPCODE code or CEMT SET SYDUMPCODE code to change the values of
the attributes accordingly.
v If you had no transaction dump when a transaction abended, look first to see
if attribute TRANDUMP or NOTRANDUMP is specified for this dump code. The
attribute needs to be TRANDUMP if a transaction dump is to be taken.
If the attribute is shown to be TRANDUMP, look next at the maximum number of
dumps specified for this dump code, and compare it with the current number. The
values are probably equal, showing that the maximum number of dumps have
already been taken.
v If you had a transaction dump but no system dump, use CEMT INQ
TRDUMPCODE and check whether there is an attribute of SYSDUMP or
NOSYSDUMP for the dump code. You need to have SYSDUMP specified if you
are to get a system dump as well as the transaction dump.
Check also that you have not had all the dumps for this dump code, by
comparing the maximum and current dump values.
v If you had no system dump when a system abend occurred, use CEMT INQ
SYDUMPCODE and check whether you have an attribute of SYSDUMP or
NOSYSDUMP for the dump code. You need SYSDUMP if you are to get a
system dump for this type of abend.
Finally, check the maximum and current dump values. If they are the same, you
need to reset the current value to zero.
Note: SDUMPs produced by the kernel do not use the standard dump domain
mechanisms, and always have a dump ID of 0/0000.
The complete range of dump IDs for any run of CICS is, therefore, distributed
between the set of system dumps and the set of transaction dumps, but neither set
of dumps has them all.
Figure 32 gives an example of the sort of distribution of dump IDs that might occur.
Note that each dump ID is prefixed by the run number, in this case 23, and that this
is the same for any dump produced during that run. This does not apply to
SDUMPs produced by the kernel; these always have a dump ID of 0/0000.
For further discussion of the way CICS manages transaction and system dumps,
┌───────────────────────────┬─────────────────────────────────┐
│ On system dump data set │ On transaction dump data set │
├───────────────────────────┼─────────────────────────────────┤
│ ID=23/0001 │ │
│ ID=23/0002 │ ID=23/0002 │
│ │ ID=23/0003 │
│ ID=23/0004 │ │
│ │ ID=23/0005 │
│ ID=23/0006 │ │
│ ID=23/0007 │ │
│ │ ID=23/0008 │
└───────────────────────────┴─────────────────────────────────┘
Figure 32. Typical distribution of dump IDs between dump data sets
You did not get the correct data formatted from a CICS system dump
If you did not get the correct data formatted from a CICS system dump, these are
the most likely explanations:
v You did not use the correct dump formatting keywords. If you do not specify any
formatting keywords, the whole system dump is formatted. However, if you
specify any keywords at all, you must be careful to specify keywords for all the
functional areas you are interested in.
v You used the correct dump formatting keywords, but the dump formatting
program was unable to format the dump correctly because it detected an error. In
such a case, you should be able to find a diagnostic error message from the
dump formatter.
v A partial dump might have been specified at the MVS level, for example “without
LPA”. This requirement would be recorded in the MVS parameter library.
For the present purpose, a terminal is considered to be any device where data can
be displayed. It might be some unit with a screen, or it could be a printer. Many
Broadly, there are two types of incorrect output that you might get on a screen, or
on a printer:
v The data information is wrong, so unexpected values appear on the screen or in
the hard copy from a printer.
v The layout is incorrect on the screen or in the hard copy. That is, the data is
formatted wrongly.
In practice, you may sometimes find it difficult to distinguish between incorrect data
information and incorrect formatting. In fact, you seldom need to make this
classification when you are debugging this type of problem.
Sometimes, you might find that a transaction runs satisfactorily at one terminal, but
fails to give the correct output on another. This is probably due to the different
characteristics of the different terminals, and you should find the answer to the
problem in the sections that follow.
If you get a logon rejection message when you attempt to log on to CICS, it could
be that the TYPETERM definitions for the terminal are incorrect. A message
recording the failure is written to the CSNE log or, in the case of autoinstall, to the
CADL log.
You are likely to get a logon rejection if you attempt to specify anything other than
QUERY(NO) for a terminal that does not have the structured query field feature.
Note that NO is the default value for TYPETERM definitions that you supply, but
YES is the value for TYPETERM definitions that are supplied with CICS.
If the “wrong data” is in the form of a message or code that you do not understand,
look in the appropriate manual for an explanation of what it means.
Messages that are prefixed by DFH originate from CICS—use the CMAC
transaction or look in the CICS Messages and Codes manual for these. For codes
that appear in the space at the bottom of the screen where status information is
displayed, look in the appropriate guide for the terminal.
The following are examples of common errors that can cause messages or codes
to be displayed:
v SCRNSIZE(ALTERNATE) has been specified in a PROFILE, and too many rows
have been specified for ALTSCREEN and ALTPAGE in the TYPETERM definition
for the terminal.
v An application has sent a spurious hex value corresponding to a control
character in a data stream. For example, X'11' is understood as “set buffer
address” by a 3270 terminal, and the values that follow are interpreted as the
new buffer address. This eventually causes an error code to be displayed.
If you suspect this may be the cause of the problem, check your application code
carefully to make sure it cannot send any unintended control characters.
v EXTENDEDDS(YES) has been specified for a device that does not support this
feature. In such a case, a message is sent to the screen, and a message might
also be written to the CSMT log.
The default value for EXTENDEDDS is NO, but check to make sure that YES
has not been specified if you know your terminal is not an extended data stream
device.
If the data displayed on your terminal has unexpectedly been translated into
uppercase characters, or if you have some lowercase characters when you were
expecting uppercase translation, you need to look at the options governing the
translation.
These are the significant properties of the various translation options you have:
v The ASIS option for BMS or terminal control specifies that lowercase characters
in an input data stream are not to be translated to uppercase.
ASIS overrides the UCTRAN attributes for both TYPETERM and PROFILE
definitions.
v The UCTRAN attribute of the TYPETERM definition states whether lowercase
characters in input data streams are to be translated to uppercase for terminals
with this TYPETERM definition.
The UCTRAN attribute of TYPETERM is overridden by ASIS, but it overrides the
UCTRAN attribute of a PROFILE definition.
v The UCTRAN attribute of a PROFILE states whether lowercase characters in the
input data stream are to be translated to uppercase for transactions with this
PROFILE running on VTAM terminals. The PROFILE UCTRAN value is valid only
for VTAM terminals.
Note: User exit XZCIN can also be used to perform uppercase translation.
Figure 33 and Figure 34 summarize whether or not you get uppercase translation,
depending on the values of these options.
┌──────────────────┐ ┌────────────────────────────────────┐
│ │ │ │
│ ASIS option │ │ TYPETERM │
│ │ │ │
│ not specified │ ├─────────────────┬──────────────────┤
│ │ │ │ │
└──────────────────┘ │ UCTRAN(YES) │ UCTRAN(NO) │
│ │ │
┌────┬───────────────┼─────────────────┼──────────────────┤
│ P │ │ │ │
│ R │ UCTRAN(YES) │ YES │ YES │
│ O │ │ │ │
│ F ├───────────────┼─────────────────┼──────────────────┤
│ I │ │ │ │
│ L │ UCTRAN(NO) │ YES │ NO │
│ E │ │ │ │
└────┴───────────────┴─────────────────┴──────────────────┘
┌──────────────────┐ ┌────────────────────────────────────┐
│ │ │ │
│ ASIS option │ │ TYPETERM │
│ │ │ │
│ is specified │ ├─────────────────┬──────────────────┤
│ │ │ │ │
└──────────────────┘ │ UCTRAN(YES) │ UCTRAN(NO) │
│ │ │
┌────┬───────────────┼─────────────────┼──────────────────┤
│ P │ │ │ │
│ R │ UCTRAN(YES) │ NO │ NO │
│ O │ │ │ │
│ F ├───────────────┼─────────────────┼──────────────────┤
│ I │ │ │ │
│ L │ UCTRAN(NO) │ NO │ NO │
│ E │ │ │ │
└────┴───────────────┴─────────────────┴──────────────────┘
During the CRTE routing session, uppercase translation is dictated by the typeterm
of the terminal at which CRTE was initiated and the transaction profile definition of
the transaction being initiated (which has to be a valid transaction on the application
owning region) as shown in Table 29.
Table 29. Uppercase translation during CRTE session
TYPETERM UCTRAN TRANSACTION INPUT TRANSLATED TO UPPERCASE
PROFILE (AOR)
UCTRAN
YES YES/NO ALL OF THE INPUT
NO NO NONE OF THE INPUT. See note.
NO YES ALL OF THE INPUT EXCEPT THE
TRANSID. See note.
TRANID YES ALL OF THE INPUT
TRANID NO TRANSID ONLY
Note: Note that if the transid CRTE is not entered in upper case, it will not be recognized
(unless there is a lower/mixed case alias defined on the AOR) and message DFHAC2001 will
be issued.
During a CRTE routing session, if the first six characters entered at a screen are
CANCEL, CICS will recognize this input in upper, lower or mixed case and end the
routing session.
For more information on the ALIAS attribute of the transaction definition, see the
‘Transaction’ section of the CICS Resource Definition Guide.
Be aware that when transaction routing from CICS Transaction Server for z/OS,
Version 2 Release 1 to an earlier release of CICS that does not support transaction
based uppercase translation, uppercase translation only occurs if it is specified in
the typeterm.
In a single system, if the EXEC CICS SET TERMINAL command is issued for a
terminal while it is running a transaction performing RECEIVE processing,
unpredictable results may occur. This is because the command can override the
typeterm definition regarding uppercase translation and RECEIVE processing
interrogates the uppercase translate status of the terminal in order to establish
whether translation is required.
In a transaction routing environment, the system programmer who issues the EXEC
CICS SET TERMINAL command should be aware (for VTAM terminals) that the
TOR terminal uppercase translate status is copied to the AOR surrogate terminal on
every flow across the link from the TOR to the AOR. Consequently:
v The EXEC CICS SET TERMINAL change of uppercase translate status will only
take effect on the AOR on the next flow across the link.
v Any AOR typeterm definition used to hard code remote terminal definitions will be
overridden with the TOR values for uppercase translate status.
v EXEC CICS INQUIRE TERMINAL issued on the AOR can return misleading
uppercase translation status of the terminal, since the correct status on the TOR
may not yet have been copied to the AOR.
v The processing of RECEIVE requests on the TOR and AOR can interrogate the
uppercase translate status of the terminal. Therefore unpredictable results can
also occur if the system programmer issues the EXEC CICS SET TERMINAL
command during receive processing.
If the codepage sent by a client is incorrect, this can lead to the entire screenful of
data being incorrect. You must resolve this problem at the client end of operations.
If you are using a Katakana terminal, you might see some messages containing
mixed English and Katakana characters. That is because Katakana terminals
cannot display mixed-case output. Uppercase characters in the data stream appear
as uppercase English characters, but lowercase characters appear as Katakana
characters. If you have any Katakana terminals connected to your CICS system,
specify MSGCASE=UPPER in the system initialization table to ensure that
messages contain uppercase characters only.
If the data values are wrong on the user’s part of the screen (the space above the
area used to display status information to the operator), or in the hard copy
produced by a printer, it is likely that the application is at fault.
If you find that some data is not being displayed, consider these possibilities:
v The SENDSIZE value for the TYPETERM definition could be too large for the
device receiving the data. Its receiving buffer could then overflow, with some data
being lost.
v SCRNSIZE(ALTERNATE) might be specified in the PROFILE definition for the
transaction running at the terminal, while default values for ALTSCREEN and
ALTPAGE are allowed in the TYPETERM definition for the terminal.
The default values for ALTSCREEN and ALTPAGE are 0 rows and 0 columns, so
no data could then be displayed if SCRNSIZE(ALTERNATE) were specified.
v EXTENDEDDS(YES) is specified for a device that does not support this feature.
Early data can be overlaid by later data, so that data appears in the wrong order,
when the SENDSIZE value of the TYPETERM definition is too large for the device
receiving the data. This is because the buffer can wrap when it is full, with the
surplus data overlaying the first data that was received.
Incorrect formatting of data can have a wide range of causes, but here are some
suggestions of areas that can sometimes be troublesome:
v BMS maps are incorrect.
v Applications have not been recompiled with the latest maps.
v Different numbers of columns have been specified for ALTSCREEN and
ALTPAGE in the TYPETERM definitions for the terminal. This can lead to
unpredictable formatting errors. However, you will not see them unless
SCRNSIZE(ALTERNATE) has been specified in the PROFILE for the transaction
running at the terminal.
v The PAGESIZE values included in the TYPETERM definitions must suit the
characteristics of the terminal, or you get formatting errors.
For a screen display, the number of columns specified must be less than or
equal to the line width. For a printer, the number of columns specified must be
less than the line width, or else both BMS (if you are using it) and the printer
might provide a new line and you will get extra spacing you do not want.
The default values for PAGESIZE depend on the value you specify for the
DEVICE keyword.
v If you get extra line feeds and form feeds on your printer, it could be that an
application is sending control characters that are not required because the printer
is already providing end of line and end of form operations.
If your application is handling the buffering of output to a printer, make sure that
an “end of message” control character is sent at the end of every buffer full of
data. Otherwise, the printer might put the next data it receives on a new line.
For a description of the use of these two types of tracing in CICS problem
determination, see “Chapter 15. Using traces in problem determination” on
page 225.
If the first transaction were to take some action based on the value of the record,
the action would probably be erroneous.
For example, in inventory control, a warehouse has 150 items in stock. 100 items
are sold to a customer, who is promised delivery within 24 hours. The invoice is
prepared, and this causes a transaction to be invoked that is designed to read the
inventory record from a VSAM data set and update it accordingly.
In the meantime, a second customer also asks for 100 items. The salesperson uses
a terminal to inquire on the number currently in stock. The “inquire” transaction
reads the record that has been read for update but not yet rewritten, and returns
the information that there are 150 items. This customer, too, is promised delivery
within 24 hours.
If you can find no such message, the next step is to get some information about the
status of the transaction that produced no output, your terminal, and the CICS
system.
Can you use the terminal where the transaction should have started?
Go to the terminal where the transaction should have started, and note whether the
keyboard is locked. If it is, press RESET. Now try issuing CEMT INQ TASK (or your
site replacement) from the terminal.
If you cannot issue CEMT INQ TASK from the terminal, one of these explanations
applies:
v The task that produced no output is still attached to the terminal.
v The terminal where you made the inquiry is not in service.
v There is a system-wide problem.
v You are not authorized to use the CEMT transaction. (This may be because you
have not signed on to the terminal and the CEMT transaction is not authorized
for that terminal. If you have signed on to the terminal, you are probably
authorized to use CEMT.)
Try to find a terminal where you can issue CEMT INQ TASK. If no terminal seems
to work, there is probably a system-wide problem. Otherwise, see if the task you
are investigating is shown in the summary.
v If the task is shown, it is probably still attached, and either looping or waiting.
Turn to “No output—what to do if the task is still in the system” on page 185 to
see what to do next.
If you are able to issue CEMT INQ TASK from the terminal where the transaction
was attached, one of these explanations applies:
v The transaction gave no output because it never started.
v The transaction ran without producing any output, and terminated.
v The transaction started at another terminal, and might still be in the system. If it
is still in the system, you can see it in the task summary that you got for CEMT
INQ TASK. It is probably looping or waiting. Turn to “No output—what to do if the
task is still in the system” for advice about what to do next. If you do not see the
task in the summary, turn to “No output—what to do if the task is not in the
system”.
You have a suspended task, treat this as a “wait” problem. Use the techniques of
“Chapter 6. Dealing with waits” on page 55 to investigate it further.
You have a running task, it is likely to be looping. Turn to “Chapter 7. Dealing with
loops” on page 149 to find out what to do next.
Note: If you’re not getting output on a printer, the reason could be simply that
you are not setting on the START PRINTER bit in the write control
character. You need to set this bit to get printed output if you have
specified the STRFIELD option on a CONVERSE or SEND command,
which means that the data area specified in the FROM option contains
structured fields. Your application must set up the contents of the
structured fields.
Your task might have been initiated by direct request from a terminal, or by
automatic task initiation (ATI). Most of the techniques apply to both sorts of task,
but there are some extra things to investigate for ATI tasks. Carry out the tests
which apply to all tasks first, then go on to the tests for ATI tasks if you need to.
You need to use the CETR transaction to set up the right tracing options. You may
need to see “Chapter 15. Using traces in problem determination” on page 225 for
guidance about setting up trace options.
Select special tracing for just your task, and disable tracing for all other tasks by
setting the master system trace flag off. Set up special tracing for the level one
trace points for the components that are likely to be used during the invocation of
the task. The components you choose will depend on how the task is initiated—by
direct request from a terminal, or by automatic transaction initialization—but they
should include loader domain (LD), program manager (PG), transaction manager
(XM), and dispatcher domain (DS). Make sure that special tracing is disabled for all
other components, to minimize the amount of trace data that is collected and the
tracing overhead.
Now turn tracing on, and attempt to start your task. When you are sure that the
time has passed when the output should have appeared, stop tracing, and format
the trace data set.
If your transaction ran, you should see the following types of trace entries for your
task and the programs associated with it:
1. Loader domain, when it loaded your program, if the program was not already in
main storage.
2. Transaction manager, when it attached your task to the dispatcher.
3. Dispatcher domain, when your task got its first dispatch. You might also see
subsequent entries showing your task being suspended, and then resumed.
4. Program manager, for any program management functions associated with your
task.
If trace entries for any of these processes are missing, that should help you to find
where the failure occurred.
Using EDF
If the transaction being tested requires a terminal, you can use EDF. You need two
other terminals for input, as well as the one that the transaction requires (“tttt”). Use
one of these others to put the transaction terminal under control of EDF, with:
CEDF tttt
Using CEDX
You can use CEDX to debug non-terminal transactions. CICS intercepts the
transaction specified on the CEDX tranid command, and displays the EDF
diagnostic panels at the terminal at which the EDF command is issued.
CEDX provides the same function and diagnostic display panels as CEDF, and the
same basic rules for CEDF also apply to CEDX.
Using statistics
If no one else is using the transaction in question, you can tell from CICS statistics
whether the program has been executed or not.
Now initiate the transaction and wait until it should have been executed. Repeat the
CEMT PERFORM STATISTICS RECORD command, to get a new set of statistics
written to the SMF data set. Format the data from the SMF data set for the APPLID
that interests you, and look at the statistics recorded before and after you attempted
to execute the transaction. If the count for your transaction increased by 1, it was
executed. If it remained the same, it was not executed.
Alternatively, if no one else is using the transaction, you can tell, using CEMT,
whether the program is being executed. Use the command CEMT INQUIRE
PROGRAM(xxxxxxxx) where xxxxxxxx is the program name. The screen presented
to you includes a USECOUNT value. This value is the number of times that the
program has been executed since the start of the current CICS session.
Now initiate the transaction and wait until it should have been executed. Repeat the
CEMT INQUIRE PROGRAM(xxxxxxxx) and the USECOUNT value will have been
incremented if the program has been executed.
Formatting the SMF data set. The statistics utility program, DFHSTUP, prepares
and prints reports offline using the data recorded in the SMF data set. Read the
‘DFHSTUP’ section in the CICS Operations and Utilities Guide for details on how to
use this facility.
When you format the SMF data set using DFHSTUP in order to look at the statistics
relating to executed transactions and programs, you may find the following
DFHSTUP control parameters useful:
SELECT APPLID=
COLLECTION TYPE=REQ
TIME START= ,STOP=
DATE START= ,STOP=
See the ‘DFHSTUP’ section in the CICS Operations and Utilities Guide for details
on how to code these parameters. If you correctly code these control parameters,
you avoid the formatting of much information that might be unnecessary at this
point.
Using CEBR
You can use CEBR to investigate your transaction if the transaction reads or writes
to a transient data queue, or writes to a temporary storage queue. A change in such
a queue is strong evidence that the transaction ran, provided that the environment
is sufficiently controlled that nothing else could produce the same effect. You need
to be sure that no other transaction that might be executed while you are doing
your testing does the same thing.
The absence of such a change does not mean that the transaction did not run—it
may have run incorrectly, so that the expected change was not made.
DFHAC2008 date time applid Transaction tranid has been disabled and cannot
be used
If you do not get this message, it is likely that your transaction did not start because
of a problem with that terminal.
If you find an ICE for your task, look in field ICEXTOD. That will show you the
expiration time of day. Does it contain the value you expect? If not, either the task
which caused this one to be autoinitiated was in error, or there is a system problem.
AIDs are hung off system entries with their forward and backward chain pointers at
offset ’0C’ and ’10’ respectively. AIDs contain the following fields that can be useful
in debugging.
AIDTYPE (X'2D')
Type of aid:
Table 30. Contents of AIDTYPE field
Content Offset Meaning
AIDBMS X'80' BMS AID
AIDPUT X'50' Start with data
AIDINT X'40' Start with no data
AIDTDP X'10' Transient data AID
AIDISC X'08' Queued allocate type AID
AIDCRRD X'04' Remote delete type AID
AIDSTATI (X'2E')
AID status indicator:
Table 31. Contents of AIDSTATI field
Content Offset Meaning
AIDPRIV X'80' Privileged allocate
AIDSENT X'40' This has been sent to the TOR by CRSR
AIDCANCL X'20' Cancel this AID
AIDROUTP X'10' Not yet routed to the AOR
AIDSHIPD X'08' Prevent duplicate send
AIDREMX X'04' AID for a remote transaction
AIDREMT X'02' AID for a remote terminal
AIDSTTSK X'01' Task already initiated
AID_TOR_NETNAME (X'65')
Netname of the owning region for a specific terminal
AID_TERMINAL_NETNAME (X'5D')
Netname of terminal
AIDDATID (X'34')
TS queue name holding the data.
AID_REROUTED (X'4E')
AID rerouted to a different TOR
You can see the AIDs in the TCP section of the formatted system dump. Look in
field AIDTRNID (the 4-character transaction ID) of each AID, to see if it relates to
your task.
If you do find an AID that relates to your task, your task is scheduled to start, but
cannot do so because the terminal is unavailable. Look in field AIDTRMID to find
the symbolic ID of the terminal, and then investigate why the terminal is not
Figure 35 illustrates how data flows between various CICS resources when a
transaction is executed, and shows the points at which the data might become
invalid.
The data might be corrupted at any of points 1 through 5, as it flows from file to
terminal.
1. Data records might be incorrect, or they could be missing from the file.
2. Data from the file might be mapped into the program incorrectly.
3. Data input at the terminal might be mapped into the program incorrectly.
4. Bad programming logic might corrupt the data.
5. The data might be mapped incorrectly to the terminal.
If you find bad data in the file or data set, the error is likely to have been caused by
the program that last updated the records containing that data. If the records you
expected to see are missing, make sure that your application can deal with a
‘record not found’ condition.
If the data in the file is valid, it must have been corrupted later on in the processing.
Is the data contained in the record that is read compatible with the data declaration
in the program?
Check each field in the data structure receiving the record, making sure in particular
that the type of data in the record is the same as that in the declaration, and that
the field receiving the record is the right length.
If the program receives input data from the terminal, make sure that the relevant
data declarations are correct for that, too.
If there seems to be no error in the way in which the data is mapped from the file or
terminal to the program storage areas, the next thing to check is the program logic.
You can determine the flow of data through your transaction by “desk checking”, or
by using the interactive tools and tracing techniques supplied by CICS.
Desk checking your source code is sometimes best done with the help of another
programmer who is not familiar with the program. It is often possible for such a
person to see weaknesses in the code which you have overlooked.
Interactive tools allow you to look at the ways in which the data values being
manipulated by your program change as the transaction proceeds.
v CEDF is, perhaps, the most powerful interactive tool for checking your
programming logic. You can use it to follow the internal flow from one CICS
command-level statement to another. If necessary, you can add CICS statements
such as ASKTIME at critical points in your program, to see if certain paths are
taken, and to check program storage values.
v CECI allows you to simulate CICS command statements. Try to make your test
environment match the environment in which the error occurred as closely as
possible. If you do not, you might find that your program works with CECI, but
not otherwise.
v CEBR enables you to look at temporary storage and transient data queues, and
to put data into them. This can be useful when many different programs use the
queues to pass data.
Note: When you use CEBR to look at a transient data queue, the records you
retrieve are removed from the queue before they are displayed to you.
This could alter the flow of control in the program you are testing. You
can, however, use CEBR to copy transient data queues to and from
temporary storage, as a way of preserving the queues if you need to.
User tracing allows you to trace the flow of control and data through your program,
and to record data values at specific points in the execution of the transaction. You
could, for example, look at the values of counters, flags, and key variables during
the execution of your program. You can include up to 4000 bytes of data on any
trace entry, and so this can be a powerful technique for finding where data values
are being corrupted.
CSFE storage freeze can be used to freeze the storage associated with a terminal
or a transaction so that it is not FREEMAINed at the end of processing. This can be
a useful tool if, for example, you want to investigate possible storage violations. You
need to get a transaction dump to look at the storage after you have run the task
with storage freeze on.
For long-running tasks, there is a possibility that a large amount of storage may be
consumed because it cannot be FREEMAINed while storage freeze is on. For
short-running tasks, however, there should be no significant overhead.
If, after using these techniques, you can find no fault with the logic of the program,
the fault either lies with the way data is mapped to the terminal, or you could have
missed some important evidence.
Note: The MDT is turned on automatically if the operator types data in the
field. If, however, the operator does not type data there, the application
must turn the tag on explicitly if the field is to be read in.
v If your program changes a field attribute byte, or a write control character, look at
each bit and check that its value is correct by looking in the appropriate
reference manual for the terminal.
Even if your system uses all the CICS storage protection facilities, CICS storage
violations can occur in certain circumstances in systems using storage protection.
For example:
v An application program could contain the necessary instructions to switch to
CICS key and modify CICS storage.
v An application program could contain the necessary instructions to switch to the
basespace and modify other transactions’ storage.
v An application program could be defined with EXECKEY(CICS) and could thus
modify CICS storage and other transactions’ storage.
v An application could overwrite one or more storage check zones in its own
task-lifetime storage.
To gain the full benefit of CICS storage protection, you need to examine the storage
needs of individual application programs and control the storage key definitions that
are used.
When CICS detects and prevents an attempted storage violation, the name of the
abending program and the address of the area it tried to overwrite are passed to
the program error program (DFHPEP). For programming information about
DFHPEP, see the CICS Customization Guide.
If a storage violation occurs in your system, please read the rest of this section.
If you have received this message, turn first to the description of message
DFHSM0102 in the CICS Messages and Codes manual to see an explanation of
the message, and then to the CICS Trace Entries to see an explanation of the
exception trace point ID, X'code'. This tells you how CICS detected the storage
violation. Then return to this section, and read “CICS has detected a storage
violation”.
Storage violations not detected by CICS are less easy to identify. They can cause
almost any sort of symptom. Typically, you may have got a program check with a
condition code indicating ‘operation exception’ or ‘data exception’, because the
program or its data has been overlaid. Otherwise, you might have obtained a
message from the dump formatting program saying that it had found a corrupted
data area. Whatever the evidence for the storage violation, if it has not been
detected by CICS, turn to “Storage violations that affect innocent transactions” on
page 199.
CICS detects storage violations involving TIOAs by checking the SAA chains when
it receives a command to FREEMAIN an individual element of TIOA storage, at
least as far as the target element. It also checks the chains when it FREEMAINs
the storage belonging to a TCTTE after the last output has taken place. CICS
detects storage violations involving user-task storage by checking the storage check
zones of an element of user-task storage when it receives a command to
FREEMAIN that element of storage. It also checks the chains when it FREEMAINs
all the storage belonging to a task when the task ends.
The storage violation is detected not at the time it occurs, but only when the SAA
chain or the storage check zones are checked. This is illustrated in Figure 36 on
page 195, which shows the sequence of events when CICS detects a violation of a
user task storage element. The sequence is the same when CICS detects a
violation of a TIOA storage element.
The fact that the SAA or storage check zone is overlaid some time before it is
detected does not matter too much for user storage where the trailing storage
check zone has been overlaid, because the transaction whose storage has been
violated is also very likely to be the one responsible for the violation. It is fairly
common for transactions to write data beyond the end of the allocated area in a
storage element and into the check zone. This is the cause of the violation in
Figure 36 on page 195.
The situation could be more serious if the leading check zone has been overlaid,
because in that case it could be that some other unrelated transaction was to
blame. However, storage elements belonging to individual tasks are likely to be
more or less contiguous, and overwrites could extend beyond the end of one
element and into the next.
Finding the offending transaction when the duplicate SAA of a TIOA storage
element has been overlaid might not be so straightforward. This is because TIOAs
tend to have much longer lifetimes than tasks, because they wait on the response
of terminal operators. By the time the storage violation is detected, the transaction
that caused it is unlikely to still be in the system. However, the techniques for
CICS-detected violations still apply.
Storage element
│
┌───────────────────────┴───────────────────────┐
│ │
┌────────────┬────────────────────┬─────────────┐
User task issued │ Leading │ │ Trailing │
GETMAIN; │ storage │ │ storage │
storage element is │ check zone │ │ check zone │
obtained. └────────────┴────────────────────┴─────────────┘
Data written by task
│
┌──────────┴─────────────────┐
│ │
Task writes data, ┌────────────┬────────────────────────────┬─────┐
overlaying the │ Leading │----------------------------│ │
trailing storage │ storage │----------------------------│ │
check zone. │ check zone │----------------------------│ │
└────────────┴────────────────────────────┴─────┘
Task continues.
Storage check zones do not match
│
┌────────────────┴──────────────────┐
┌───────┴────┐ ┌─────┴───┐
│ │ │ │
Task ends. CICS ┌────────────┬────────────────────────────┬─────┐
attempts to FREEMAIN │ Leading │----------------------------│ │
the storage but finds │ storage │----------------------------│ │
that the two storage │ check zone │----------------------------│ │
check zones are not └────────────┴────────────────────────────┴─────┘
identical.
CICS issues error
message and continues. ┌────────────┬────────────────────────────┬─────┐
The corrupted storage │ Leading │----------------------------│ │
element remains │ storage │----------------------------│ │
unchanged and cannot │ check zone │----------------------------│ │
be reused unless └────────────┴────────────────────────────┴─────┘
storage recovery is on.
Note: For storage elements with SAAs, the address that is returned on the
GETMAIN request is that of the leading SAA; for storage elements with
storage check zones, the address that is returned is that of the beginning of
usable storage.
If storage recovery is not on, CICS abends the transaction whose storage has been
violated (if it is still running). If the transaction is running when the error is detected
and if dumping is enabled for the dump code, a transaction dump is taken.
If you received a transaction abend message, read What the transaction abend
message can tell you. Otherwise, go on to What the CICS system dump can tell
you.
Because CICS does not detect the overlay at the time it occurs, the program
identified in the abend message probably is not the one in error. However, it is likely
that it issued the FREEMAIN request on which the error was detected. One of the
other programs in the abended transaction might have violated the storage in the
first place.
The dump formatting program reports the damaged storage check zone or SAA
chain when it attempts to format the storage areas, and this can help you with
diagnosis by identifying the TCA or TCTTE owning the storage.
When you have formatted the dump, take a look at the data overlaying the SAA or
storage check zone to see if its nature suggests which program put it there. There
are two places you can see this, one being the exception trace entry in the internal
trace table, and the other being the violated area of storage itself. Look first at the
exception trace entry in the internal trace table to check that it shows the data
overlaying the SAA or storage check zone. Does the data suggest what program
put it there? Remember that the program is likely to be part of the violated
transaction in the case of user storage. For terminal storage, you probably have
more than one transaction to consider.
As the SAAs and storage check zones are only 8 bytes long, there might not be
enough data for you to identify the program. In this case, find the overlaid data in
the formatted dump. The area is pointed to in the diagnostic message from the
If the investigations you have done so far have enabled you to find the cause of the
overlay, you should be able to fix the problem.
You do this by forcing CICS to check the SAA chain of terminal storage and the
storage check zones of user-task storage every time an old-style trace entry is
made from AP domain. These types of trace entry have point IDs of the form AP
00xx, “xx” being two hexadecimal digits. Storage chain checking is not done for
new-style trace entries from AP domain or any other domain. (For a discussion of
old and new-style trace entries, see “Chapter 15. Using traces in problem
determination” on page 225.)
Table 32 on page 197 shows the CSFE DEBUG options and their effects. Table 33
shows the startup overrides that have the same effects.
Table 32. Effects of the CSFE DEBUG transaction
CSFE syntax Effect
CSFE DEBUG, This checks storage check
zones for all storage areas on
CHKSTSK=CURRENT the transaction storage chain for
the current task only.
Your strategy should be to have the minimum tracing that will capture the storage
violation, to reduce the processing overhead and to give you less trace data to
process. Even so, you are likely to get a large volume of trace data, so direct the
tracing to the auxiliary trace data sets. For general guidance about using tracing in
CICS problem determination, see “Chapter 15. Using traces in problem
determination” on page 225.
You need to have only level-1 tracing selected, because no user code is executed
between level-2 trace points. However, you do not know which calls to CICS
components come before and after the offending code, so you need to trace all
CICS components in AP domain. (These are the ones for which the trace point IDs
have a domain index of “AP”.) Set level-1 tracing to be special for all such
components, so that you get every AP level-1 trace point traced using special task
tracing.
If the trailing storage check zone of a user-storage element has been overlaid,
select special tracing for the corresponding transaction only. This is because it is
very likely to be the one that has caused the overlay.
If the duplicate SAA of a TIOA has been overlaid, you need to select special tracing
for all tasks associated with the corresponding terminal, because you are not sure
which has overlaid the SAA. It is sufficient to select special tracing for the terminal
and standard tracing for every transaction that runs there, because you get special
task tracing with that combination. (See Figure 40 on page 236.)
When you have set up the tracing options and started auxiliary tracing, you need to
wait until the storage violation occurs.
The value of 'code' is equal to the exception trace point ID, and it identifies the type
of storage that was being checked when the error was detected. A description of
the exception trace point ID, and the data it contains, is in the CICS Trace Entries.
Format the system dump using the formatting keyword TR, to get the internal trace
table. Locate the exception trace entry made when the storage violation was
detected, near the end of the table. Now scan back through the table, and find the
last old-style trace entry (AP 00xx). The code causing the storage violation was
being executed between the time that the trace entry was made and the time that
the exception trace entry was made.
If you have used the CHKSTSK=CURRENT option, you can locate the occurrence
of the storage violation only with reference to the last old-style trace entry for the
current task.
You need to identify the section of code that was being executed between the two
trace entries from the nature of the trace calls. You then need to study the logic of
the code to find out how it caused the storage violation.
For suggestions on programming errors that might have caused your particular
problem, look at the list of common ones given in “Programming errors that can
cause storage violations” on page 201.
If they are reproducible, storage violations of this type typically occur at specific
offsets within structures. For example, the start of an overlay might always be at
offset 30 from the start of a field.
The most likely cause of such a violation is a transaction writing data to a part of
the DSAs that it does not own, or possibly FREEMAINing such an area. The
transaction might previously have GETMAINed the area and then FREEMAINed it
before writing the data, or addressability might otherwise not have been correctly
maintained by an application. Another possible reason is that an ECB might have
been posted by a transaction after the task that was waiting on it had been
canceled.
The trace table must go back as far as task attach of the program causing the
overlay, because that trace entry relates the transaction’s identity to the unit of work
number used on subsequent entries. This could mean that a very large trace table
is needed. Internal trace is not suitable, because it wraps when it is full and it then
overwrites important trace entries.
Auxiliary trace is a suitable destination for recording long periods of system activity,
because it is possible to specify very large auxiliary trace data sets, and they do not
wrap when they are full.
If you have no idea which transaction is causing the overlay, you need to trace the
activities of every transaction. This impacts performance, because of the processing
overhead.
Use the CETR transaction to set up the tracing options, and select auxiliary trace
as the trace destination. When you get the symptoms that tell you that the storage
violation has occurred, take a system dump—unless the error causes a system
dump to be taken.
Format the system dump, and format and print the auxiliary trace data set. If you
know which area of storage the violation occurred in, you can use appropriate dump
formatting keywords. Otherwise, you need to format the entire system dump. The
dump formatting program may report that it has found some incorrect data. If not,
you need to find the overlaid area by other means.
The next job is to locate all the entries in the trace table that address the overlaid
area. Operations involving GETMAIN and FREEMAIN in particular are likely
pointers to the cause of the error.
When you have found a likely trace entry, possibly showing a GETMAIN or
FREEMAIN addressing the area, you need to find the ID of the associated
transaction by locating the trace entry for TASK ATTACH. Rather than locating this
manually, it is probably better to reformat the auxiliary trace data set selectively to
show just trace entries corresponding to the task’s unit of work.
Having found the identity of the transaction, take a look at all the programs
belonging to the transaction. It is likely that one of these caused the overlay, and
Storage recovery
The STGRCVY system initialization parameter enables you to vary the action taken
by CICS on detection of a storage violation.
In normal operation, CICS sets up four task-lifetime storage subpools for each task.
Each element in the subpool starts and ends with a check zone that includes the
subpool name. At each FREEMAIN, and at end of task, CICS inspects the check
zones and abends the task if either has been overwritten.
Terminal input-output areas (TIOAs) have similar check zones, each of which is set
up with the same value. At each FREEMAIN of a TIOA, CICS inspects the check
zones and abends the task if they are not identical.
DFHIR3799
DFHEX0001 DFHEX0011
DFHEX0002 DFHEX0012
DFHEX0003 DFHEX0013
DFHEX0004 DFHEX0014
DFHEX0005 DFHEX0015
DFHEX0010 DFHEX0016
Messages DFH5502W and DFH5503E include support for the external CICS
interface facility.
For full details of all CICS messages, see the CICS Messages and Codes.
The external CICS interface outputs trace to two destinations: an internal trace table
and an external MVS GTF data set. The internal trace table resides in the
non-CICS MVS batch region. Trace data is formatted and included in any dumps
produced by the external CICS interface.
Trace entries are issued by the external trace interface destined for the internal
trace table and/or an MVS GTF data set. They are listed in the CICS Trace Entries
manual.
The external CICS interface produces MVS SYSM dumps for some error conditions
and MVS SDUMPs for other, more serious conditions. These dumps contain all the
external CICS interface control blocks, as well as trace entries. You can use IPCS
to format these dumps.
If CSACRBA is not zero, examine the TCTSEs in System A and find the TCTSE for
System B. In this TCTSE, TCSEIRCF is the flag byte that indicates the state of
communication between the two systems. If bit TCSEIRNC in this byte is on, there
is no communication between System A and System B. This is either because
System B has not started interregion services, or because System A is out of
service with respect to System B, or because System B is out of service with
respect to System A.
If bit TCSEIRNC is off, a session should exist. The next step is to inspect the
primary and secondary session(s) between the systems. The first primary session is
pointed to by field TCSEVC1 in the TCTSE, and the first secondary session is
pointed to by TCSEVC2. If System A initiated the session, look at secondary
sessions, otherwise look at primary sessions.
Each session is defined by a TCTTE. The field TCTESCCB in TCTTE is zero if the
session is not connected to the other system, otherwise it contains the address of
the subsystem connection control block (SCCB) that the interregion SVC routine
uses to represent that end of the connection.
The protocol for interregion SVC transfer is similar to that for VTAM SNA data flow
control. Field TCTEIRF1 contains information on the state of the session, field
TCTESBRS gives the bracket status, field TCTESRHI is the inbound request
header, and field TCTESRHO is the outbound request header.
The field TCTENIBA points to the TCTTE extension for the NIB descriptor. Within
this TCTTE extension, TCTEPSQ contains the primary name, and TCTESSQ
contains the secondary name. Thus a session in System A can be related to a
session in System B.
Categories of problem
The following categories of problem (in order of ascending impact on the user) may
be encountered by the CICS log manager:
1. Those problems within the MVS logger that the MVS logger resolves for itself.
CICS has no involvement in this category and may only experience the problem
as an increase in response times.
2. Where the MVS logger is unable to satisfy the CICS log manager’s request
immediately. This problem state can be encountered:
v For a log stream that uses a coupling facility structure, on a 'STRUCTURE
FULL' condition, where the coupling facility has reached its capacity before
offloading data to DASD. This state may also be encountered during the
rebuilding of a coupling facility structure.
v For a DASD-only log stream, on a 'STAGING DATA SET FULL' condition,
where the staging data set has reached its capacity before offloading data to
secondary storage.
For an autojournal, before you can continue to use the log stream, you must:
a. Try to read and recover data from the damaged autojournal.
System log
You are strongly recommended to allow the CICS log manager to manage the size
of the system log. If you do so, you do not need to worry about the data set limit
being exceeded, even if you are using a pre-OS/390 Release 3 version of MVS.
In the unlikely event that you need to retain data beyond the time it would be
deleted by CICS, see the CICS Transaction Server for z/OS Installation Guide for
advice on how to define the system log.
General logs
If a journal write to a user journal fails because the data set limit is reached, you
must delete the tail of the log, or archive it, before you can use the SET
JOURNALNAME command to open the journal and make it available for use again.
For an example of how to do this, see the CICS Operations and Utilities Guide.
Pre-OS/390 Release 3
v The MVS logger imposes a limit of 168 data sets per log stream.
v There is no mechanism for the automatic deletion of records from general
log streams. It is your responsibility to delete such data to prevent the 168
data set limit being exceeded.
If you need longer-term data retention, you must copy the data from log
stream storage into alternative archive storage.
Although message IXG257I is issued when 90% of the log stream has been
filled, this event is not detectable by CICS. You should use your automation
software to monitor occurrences of this message.
Note: Support for the AUTODELETE and RETPD parameters requires the
sysplex’s LOGR couple data set to have been formatted using OS/390
Release 3 or later. If it has not, refer to the “Pre-OS/390 Release 3”
box.
Explanations of MVS logger reason codes which are shown in CICS and MVS
messages and traces are in the IXGCON macro and in the OS/390 MVS Assembler
Services Reference manual.
RO *ALL,D GRS,RES=(SYSZLOGR,*)
D GRS,RES=(SYSZLOGR,*)
5. Log stream data sets are of the form IXGLOGR.stream_name.Annnnnnn. The high level qualifier (IXGLOGR) may be different if the
HLQ parameter was specified when the log stream was defined.
D GRS,RES=(SYSZLOGR,*)
This shows which tasks (that is, MVS TCBs) have exclusive enqueues on the log
streams, and which tasks are waiting for them. It is quite normal for enqueues and
latches to be obtained, occasionally with contention. They are indications of a
problem only if they last for more than a minute or so.
Long term enqueuing on the SYSZLOGR resource can be a sign of problems even
if there is no contention.
You can choose to display only those log streams exclusively enqueued on by CICS
jobs in the sysplex. Issue the following MVS command:
D GRS,RES=(DFHSTRM,*)
If the response shows that LOGR is not in use by all systems, there may be a
problem to investigate. Look for IXCxxx messages which might indicate the cause
of the problem and issue the following command to attempt reconnection to the
couple data set:
SETXCF CPL,TYPE=(LOGR),PCOUPLE=(couple_dataset_name)
To display all structures with Failed_persistent connections, issue the following MVS
command:
D XCF,STR,STRNM=*,STATUS=FPCONN
You can use wildcards to select multiple log streams. For example, the following job
produces a report on the system log streams for CICS region IYLX4:
//IYLXLIST JOB NOTIFY=WILLIN,MSGCLASS=A
//LOGLIST EXEC PGM=IXCMIAPU
//SYSPRINT DD SYSOUT=A,DCB=RECFM=FBA
//SYSIN DD *
DATA TYPE(LOGR) REPORT(NO)
LIST LOGSTREAM NAME(WILLIN.IYLX4.DFH*) DETAIL(YES)
Figure 37 on page 212 shows a typical response to this command, with system logs
streams for CICS region IYXL4.
User Data:
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
SYSTEMS CONNECTED: 1
Figure 37. Example output produced by the LIST LOGSTREAM NAME command (Part 1 of 2)
User Data:
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
SYSTEMS CONNECTED: 1
Figure 37. Example output produced by the LIST LOGSTREAM NAME command (Part 2 of 2)
A dump of XCF and MVS logger address spaces from all systems is useful in the
diagnosis of such problems. To obtain the dump, issue the following series of MVS
commands:
DUMP COMM=(meaningful dump title)
R ww,JOBNAME=(IXGLOGR,XCFAS,cics_jobname),DSPNAME=('IXGLOGR'.*,'XCFAS'.*),CONT
R xx,STRLIST=(STRNAME=structure,(LISTNUM=ALL),ACC=NOLIM),CONT
R yy,REMOTE=(SYSLIST=*('XCFAS','IXGLOGR'),DSPNAME,SDATA),CONT
R zz,SDATA=(COUPLE,ALLNUC,LPA,LSQA,PSA,RGN,SQA,TRT,CSA,GRSQ,XESDATA),END
Error records written to the MVS LOGREC data set may also be useful.
If you have applied MVS APAR OW27057, a dump of the MVS logger address
space is produced automatically if an MVS IXGBRWSE or IXGDELET request fails
because the MVS logger cannot find a specific log stream block identifier. (The
MVS logger issues a return code of 8 with a reason code of 804.) To cater for other
possible logger errors, or to obtain a dump of the CF structure associated with a
failing log stream, you can set an MVS serviceability level indication processing
(SLIP) trap. Setting a SLIP trap causes MVS to take a specified set of actions when
a specified event occurs. For example, you could specify that MVS is to take a
dump of the MVS logger address space if CICS issues a particular message.
Figure 38 on page 215 shows an example SLIP trap that captures a dump of the
CICS address space, the MVS logger address space, and the coupling facility
structure associated with the failing logstream.
-->response xx
xx,DSPNAME=('XCFAS'.*,'IXGLOGR'.*),STRLIST
=(STRNAME=structname,LOCKENTRIES,ACC=NOLIM <change STRNAME
,(LISTNUM=ALL,
-->response yy
yy,ENTRYDATA=SERIALIZE,ADJUNCT=CAPTURE)),S
DATA=(RGN,XESDATA,ALLNUC,CSA,LSQA,PSA,SQA,
SWA,TRT,COUPLE,WLM,GRSQ,LPA),
-->response zz
zz,ID=LOGR,REMOTE=(JOBLIST,DSPNAME,SDATA),
END
Figure 38. An example SLIP trap. The trap is triggered when CICS issues a DFHLG0772 message. It captures dumps
of the CICS address space, the MVS logger address space, and the CF structure associated with the failing log
stream.
In this example, the SLIP triggers when a specific CICS log manager
message—DFHLG0772—is written to the console. This is specified in the EQ
parameter of the SLIP:
+4,EQ,C4C6C8D3,+8,EQ,C7F0F7F7,+C,EQ,F2)
D F H L G 0 7 7 2 <equates to
You can also set a more “generic” trap, that is triggered by the occurence of any
one of a range of messages. For example, to cause the SLIP to be triggered by any
log manager message in the DFHLG07xx range, alter the value of the EQ
parameter to:
+4,EQ,C4C6C8D3,+8,EQ,C7F0F7),
D F H L G 0 7 <equates to
For definitive information about setting SLIP traps, see the OS/390 MVS
Diagnostics: Tools and Service Aids manual, SY28-1085-03.
After the MVS logger has restarted, you must restart all CICS regions.
CAUTION:
If you forcibly cancel the MVS logger address space (by issuing a FORCE
IXGLOGR,ARM command) or coupling facility structures used by the MVS logger
(by issuing a SETXCF FORCE,CON,STRNAME=structname,CONNAME=ALL command),
there is a risk of corruption in the CICS system logs. If the system log is
corrupted, CICS issues a message telling you that you need to perform an
initial start. Data integrity will be compromised because of the loss of log data
required for consistency.
How to perform a diagnostic run: For a diagnostic run to take place, AUTO
must be specified on the START system initialization parameter. If the system log
becomes corrupt, CICS:
v Sets the recovery manager autostart override record in the global catalog so that
the next automatic restart of CICS is a diagnostic run (AUTODIAG).
v Issues message DFHRM0152, saying that the next automatic restart will be a
diagnostic run, and should be performed before an initial start.
There may be occasions other than when the system log has become unusable
when you feel it would be useful to perform a diagnostic run. You can use the
recovery manager utility program, DFHRMUTL, to specify a diagnostic run. For
information about DFHRMUTL, see the CICS Operations and Utilities Guide.
Part 3 contains:
CICS tracing
General CICS tracing is handled by trace domain. It traces the flow of execution
through CICS code, and through your applications as well. For programming
information about how to make trace calls from within your own programs, see the
CICS Application Programming Reference manual. You can see what functions are
being performed, which parameters are being passed, and the values of important
data fields at the time trace calls are made. This type of tracing is also useful in
“first failure data capture”, if an exception condition is detected by CICS.
Trace points
Trace points are included at specific points in CICS code; from these points, trace
entries can be written to any currently selected trace destination. All CICS trace
points are listed in alphanumeric sequence in the CICS Trace Entries.
Trace levels can, in principle, vary in value in the range 1–32, but in practice nearly
all mainline trace points have a trace level of 1 or 2.
Level-1 trace points are designed to give you enough diagnostic information to fix
“user” errors. The following is a summary of where they are located, and a
description of the information they return:
v On entry to, and exit from, every CICS domain. The information includes the
domain call parameter list, and data whose address is contained in the
parameter list if it is necessary for a high-level understanding of the function to
be performed.
v On entry to, and exit from, major internal domain functions. The information
includes parameters passed on the call, and any output from the function.
v Before and after calls to other programs, for example, VTAM. The information
includes what request is to be made, the input parameters on the request, and
the result of the call.
v At many of the points where trace calls were made in CICS/MVS Version 2. The
type of information is the same as for that release.
Level-2 trace points are situated between the level-1 trace points, and they
provide information that is likely to be more useful for fixing errors within CICS
code. You probably will not want to use level-2 trace points yourself, unless you are
requested to do so by IBM support staff after you have referred a problem to them.
Level-3 trace points and above are reserved for special cases. Very few
components have trace points higher than 2, and they are only likely to be of use
by IBM support staff.
You can select how much CICS system tracing is to be done on the basis of the
trace level attributes of trace points. You can make your selection independently for
each CICS component, and you can also vary the amount of tracing to be done for
each task. This gives you control over what system tracing is done.
Note: In the storage manager component (SM), two levels of tracing, level 3 and
level 4, are intended for IBM field engineering staff. These trace levels take
effect only if specified in system initialization parameters and modify the
internal SM operation for CICS subpools as follows:
SM level 3 trace
The quickcell mechanism is deactivated. Every CICS subpool,
regardless of quickcelling requirements, will issue domain calls for
getmain and freemain services, and these calls will be traced.
SM level 4 trace
Subpool element chaining on every CICS subpool is forced. Every
CICS subpool, regardless of element chaining requirements, will use
element chaining.
Specialized trace
In addition to the general trace produced by CICS, there is a number of other, more
specialized forms of trace that you can use. These are described as follows:
v “CICS exception tracing”
v “CICS XRF tracing” on page 228
v “Program check and abend tracing” on page 230
v “CICS VTAM exit tracing” on page 230
v FEPI trace.
For information about using trace to solve FEPI problems, see the CICS Front
End Programming Interface User’s Guide.
CICS uses a similar mechanism for both exception tracing and “normal” tracing.
Exception trace entries are made from specific points in CICS code, and data is
taken from areas that might provide information about the cause of the exception.
The first data field in the trace entry is usually the parameter list from the last
domain call, because this can indicate the reason for the exception.
The exception trace points do not have an associated “level” attribute, and trace
calls are only ever made from them when exception conditions occur.
Exception trace entries are always written to the internal trace table, even if no
trace destinations at all are currently STARTED. That is why there is always an
internal trace table in every CICS region, to make sure there is always somewhere
to write exception trace entries. If the other trace destinations are STARTED, the
exception trace entries are written there, as well.
You can select tracing options so that exception traces only are made to an
auxiliary trace data set. This is likely to be useful for production regions, because it
enables you to preserve exception traces in auxiliary storage without incurring any
general tracing overhead. You need to disable all standard and special task tracing,
and enable auxiliary trace:
1. Ensure that special tracing has not been specified for any task.
2. Set the master system trace flag off.
3. Set the auxiliary trace status to STARTED, and the auxiliary trace data set and
the auxiliary switch status to whatever values you want.
Exception traces are now made to an auxiliary trace data set, but there is no other
tracing overhead.
The format of an exception trace entry is almost identical to that of a normal trace
entry. However, you can identify it by the eye-catcher *EXC* in the header.
The user exception trace entries CICS writes are identified by the character string
*EXCU in any formatted trace output produced by CICS utility programs. For
example, an application program exception trace entry generated by an EXEC
CICS ENTER TRACENUM() EXCEPTION command appears in formatted trace
output as:
USER *EXCU - APPLICATION-PROGRAM-EXCEPTION
If you use the exit programming interface (XPI) trace control function to write user
trace entries, you can use the DATA1 block descriptor to indicate whether the entry
is an exception trace entry. Enter the literal ‘USEREXC’ in the DATA1 field on the
DFHTRPTX TRACE_PUT call to identify an exception trace entry. This is
interpreted by the trace formatting utility program as follows:
USER *EXCU - USER-EXIT-PROGRAM-EXCEPTION
See the CICS Customization Guide for programming information about XPI trace
control function.
The XRF trace entries are 32 bytes long and are written to a trace table in main
storage. The table has a fixed size of 64KB, and it wraps around when it is full.
The table starts with 28 bytes of control information, in the format shown in
Table 34.
Table 34. Control information at the start of the XRF trace table
Bytes Contents
0–15 ’*** XRF TRACE **’
16–19 Address of start of trace entries
20–23 Address of end of trace entries
24–27 Address of end of most recent entry
Process IDs are assigned in order of process ATTACH starting from 1. Some
special values are used for processes which are not known to the dispatcher, but
which cause trace entries to be made. These are:
Process ID Function
X'0000' Initial attach
X'FFFE' ESPIE/ESTAE error handling
X'FFFF' Dispatcher activities.
Entry types
The entries are as follows:
Table 36. XRF trace entry types
Module Type Subtype Description
DFHWLGET 1 1 Module entry Bytes 4-11 Module name Bytes 12-15 LIFO allocation
address
DFHWLFRE 1 2 Module return Bytes 4-11 Module name Bytes 12-15 LIFO allocation
address Bytes 16-27 0
DFHWDATT 2 1 XRF process attach Bytes 4- 7 Process entry point Bytes 8-11 Initial
data parameter Bytes 12-15 Address of ESPIE routine Bytes 16-19
Address of ESTAE routine Bytes 20-23 Address of attached process
XPB Bytes 24-27 Process ID attached process XPB
DFHWDISP 2 2 XRF process detach Bytes 4-27 0
DFHWDISP 2 3 XRF process dispatch Bytes 4- 7 Address of external ECB waited
for Bytes 8-11 Address of internal ECB waited for Bytes 12-15
Awaited broadcast events which were posted Bytes 16-19
Broadcast events still posted for this process Bytes 20-23 Address
of process XPB Bytes 24-27 Locks held by this process
DFHWDWAT 2 4 XRF process wait (event data) Bytes 4- 7 Address of external ECB
to wait for Bytes 8-11 Address of internal ECB to wait for Bytes
12-15 Broadcast events to wait for Bytes 16-19 Events to be
broadcast to all processes Bytes 20-23 Events to be reset for this
process Bytes 24-27 0
DFHWDAT 2 5 XRF process wait (lock data) Bytes 4- 7 Locks to be freed Bytes
8-11 Locks to be acquired Bytes 12-19 0 Bytes 20-23 Locks held by
all other processes at time of call Bytes 24-27 Locks held by this
process at time of call
DFHWDISP 2 6 Dispatcher termination Bytes 4-27 0
DFHDISP 2 7 Dispatcher issuing OS WAIT Bytes 4-19 0 Bytes 20-23 Address of
WAIT list Bytes 24-27 Number of ECBs in WAIT list
You cannot format the program check and abend trace information directly, but you
get a summary of its contents in a formatted CICS system dump when you specify
dump formatting keyword KE. The information is provided in the form of a storage
report for each task that has had a program check or an abend during the current
run of CICS.
When CICS issues a VTAM request, VTAM services the request asynchronously
and CICS continues executing. When VTAM has finished with the request, it returns
control to CICS by driving a CICS VTAM exit. Every such exit contains a trace
point, and if CICS VTAM exit tracing is active, a trace entry is written to the GTF
trace data set. GTF tracing must be active, but you do not need to start it explicitly
from CICS. It is enough to start VTAM exit tracing from the CETR transaction and
terminal trace panel.
Note: The GTF trace data set can receive trace entries from a variety of jobs
running in different address spaces. You need to identify the trace entries
that have been made from the CICS region that interests you. You can do
this by looking at the job name that precedes every trace entry in the
formatted output.
If you select “normal” CICS tracing for the affected terminals at the same time as
you have CICS VTAM exit tracing running, you can then correlate CICS activities
more easily with the asynchronous processing done by VTAM.
If you need to turn on CICS VTAM exit tracing in an application owning region
(AOR) while you are signed-on to a terminal in a terminal owning region (TOR),
follow these steps:
1. Invoke CETR on the AOR.
2. Press PF5 to call up the CETR transaction and terminal trace screen.
3. Enter the APPLID of the TOR in the NETNAME field.
4. Complete other fields as required.
5. Press Enter.
CICS VTAM trace entries are always written to the GTF trace data set, and you can
format them in the usual way—see “Formatting and interpreting trace entries” on
page 245. Direct all “normal” CICS tracing to the GTF trace destination as well, so
you get the regular trace entries and the CICS VTAM exit trace entries in sequence
in a single data set. If you send the normal tracing to another destination, you get
only the isolated traces from the exit modules with no idea of related CICS activity.
The format of the trace entries is similar to that shown in Figure 47 on page 249.
The interpretation string contains the netname of the terminal to which the trace
entry relates, if the trace entry was made from a terminal-specific trace point. This
makes it easy to identify the terminal associated with the VTAM request. The trace
entries also contain data from one or more selected CICS data fields, for example
from the TCTTE. For guidance on interpreting the data values you might find there,
see the CICS Trace Entries.
The trace entries, which include the netname of the terminal to which they relate,
are made to the GTF trace data set. If you want to send “normal” CICS trace
entries there, you can rationalize the activities of CICS with the asynchronous
activities of VTAM. For details of VTAM buffer tracing, see the appropriate manual
in the VTAM library.
You can select any combination of internal tracing, auxiliary tracing and GTF tracing
to be active at the same time. Your choice has no effect on the selectivity with
which system tracing is done, but each type of tracing has a set of characteristic
properties. These properties are described in “CICS internal trace” on page 241,
“CICS auxiliary trace” on page 241, and “CICS GTF trace” on page 242.
For each component, you can specify two sets of trace level attributes. The trace
level attributes define the trace point IDs to be traced for that component when
standard task tracing is being done and when special task tracing is being done,
respectively.
If you are running a test region, you probably have background tracing most of the
time. In this case, the default tracing options (standard tracing for all transactions,
and level-1 trace points only in the standard set for all components) probably
suffice. All you need do is to enable the required trace destinations and set up any
related tracing options. Details are given in “Selecting trace destinations and related
options” on page 240.
When specific problems arise, you can set up special tracing so you can focus on
just the relevant tasks and components. A scheme for specifying the tracing you
need is outlined in Figure 39 on page 233.
Specific
tasks
implicated ────────────────────]───────────────────┐
in N │
problem? │
│
│ Y │
┌─────────]──────────┤ │
│ _ │
│ ┌──────────────────┐ │
│ │Identify next task│ │
│ └────────┬─────────┘ │
│ │ │
│ │
│ Non─ Transaction─ │
│ terminal ───────] specific ─────┐ │
│ task? N problem? N │ │
│ _ │
f │ Y │ Y │
│ ├─────────^──────────┘ │
│ │ Terminal─ │
│ ├─────────────^────────────── specific _
│ │ N problem? │
│ │ │
│ │ │ Y │
│ _ _ │
│ ┌───────────────────┐ ┌───────────────────┐ │
│ │ Select special │ │ Select special │ │
│ │ tracing for │ │ tracing for │ │
│ │ transaction │ │ terminal │ │
│ └─────────┬─────────┘ └─────────┬─────────┘ │
│ ├────────────────^────────────────┘ │
│ _ │
│ │
└──────────── Any more tasks? │
Y │
│ N │
├──────────────────────^───────────────────────┘
_
1
Figure 39. Outline scheme for setting up special tracing for problems (Part 1 of 3)
Specific
components
implicated ────────────────────]───────────────────┐
in N │
problem? │
│
│ Y │
┌─────────]──────────┤ │
│ _ │
│ ┌───────────────────────┐ │
│ │Identify next component│ │
│ └──────────┬────────────┘ │
│ │ │
│ │ │
│ ┌─────────────┐ │
│ Tracing │ Set special │ │
│ needed for ──────]│ tracing off ├───────┐ │
│ component? N │for component│ │ │
│ └─────────────┘ │ │
f │ Y │ │
│ _ │ │
│ ┌─────────────┐See │ │
│ Extra tracing │ Set special │note 2 │ │
│ detail │ level─1 │ │ │
│ needed for ──────]│ tracing for │ │ │
│ component? N │ component │ _ │
│ └──────┬──────┘ │ │
f │ Y │ │ │
│ _ │ │ │
│ ┌───────────────────┐ │ │ │
│ │ Select special │See │ │ │
│ │ level 1 and 2 │note 2 _ │ │
│ │ tracing for │ │ │ │
│ │ component │ │ │ │
│ └─────────┬─────────┘ │ │ │
│ │ │ │ │
│ ├──────────^─────────┴───────^──────┘ │
│ │ │
│ _ │
│ │
└────^──── Any more components? │
Y │
│ N │
│ │
├──────────────────────^───────────────────────┘
│
_
2
Figure 39. Outline scheme for setting up special tracing for problems (Part 2 of 3)
Any
standard ─────────────]─────────────┐
tracing Y │
needed? │
│
│ N │
│ │
_ _
┌───────────────────────┐See │
│Set master system │note 3 │
│trace flag off │ │
└──────────┬────────────┘ │
│ │
├────────────────^────────────────┘
│
_
┌───────────────────────┐See
│Enable trace │note 3
│destinations │
└──────────┬────────────┘
│
_
┌───────────────────────┐See
│Format and examine │note 4
│trace output │
└───────────────────────┘
Figure 39. Outline scheme for setting up special tracing for problems (Part 3 of 3)
Notes:
1. See “Tracing for selected tasks”
2. See “Selecting tracing by component” on page 237
3. See “Setting the tracing status” on page 243
4. See “Formatting and interpreting trace entries” on page 245; “Interpreting
extended-format CICS system trace entries” on page 246; and “Interpreting
abbreviated-format CICS system trace entries” on page 250.
For non-terminal transactions, a task is just an instance of the transaction. The type
of tracing you define for the transaction alone defines the type of task tracing that is
to be done.
screen shown in Figure 41. You need to type in the transaction ID or the terminal ID
or the netname for the terminal, together with the appropriate tracing.
The status can be any one of STANDARD, SPECIAL, or SUPPRESSED for the
transaction, and either STANDARD or SPECIAL for the terminal.
This screen can also be used to set up certain other terminal tracing options. You
can select ZCP tracing for a named terminal (trace point ID AP 00E6), and you can
also select CICS VTAM exit tracing for the terminal. For more details about CICS
VTAM exit tracing, see “CICS VTAM exit tracing” on page 230.
The CETR transaction can, for example, help you to get standard tracing for a
CETR Transaction and Terminal Trace
Type in your choices.
Item Choice Possible choices
Transaction ID ===> Any valid 4 character ID
Transaction Status ===> STandard, SPecial, SUppressed
Terminal ID ===> Any valid Terminal ID
Netname ===> Any valid Netname
Terminal Status ===> STandard, SPecial
Terminal VTAM Exit Trace ===> ON, OFf
Terminal ZCP Trace ===> ON, OFf
VTAM Exit override ===> NONE All, System, None
When finished, press ENTER.
PF1=Help 3=Quit 6=Cancel Exits 9=Error List
Figure 41. CETR screen for specifying standard and special task tracing
transaction when it is run at one terminal, and special tracing when it is run at a
second terminal.
┌─────────────────┐
│ TRACE POINT ─
└────────┬────────┘
│
_
Tracing Y
suppressed for ──────────────────────]────────────────────┐
this task? │
│
│ N _
_ │
│
Standard Y Master N │
tracing required ─────────────] system trace ──────]──────┤
for this task? flag on? │
│
│ N │ Y _
_ _ │
│
N Special Standard N │
┌─ tracing specified tracing specified ────]──────┤
│ for this domain for this domain │
│ and level? and level? │
│ │
│ │Y │Y │
│ │ │ _
│ ├──────────────^───────────────┘ │
│ │ │
_ _ │
│ ┌─────────┐ ┌─────────┐ │
│ │ Trace │ │ Trace │ │
│ │ call │ ┌────────G│ call │H──────────────┘
│ │ made │ │ │ not made│
│ └─────────┘ │ └─────────┘
│ │
└───────────]─────────────┘
Figure 42. Logic used to determine if a trace call is to be made from a trace point
Note: The component codes BF, BM, BR, CP, DC, DI, EI, FC, IC, IS, KC, PC, SC,
SZ, TC, TD, TS, UE, and WB are subcomponents of the AP domain. The
corresponding trace entries are produced with a point ID of AP nnnn.
For example, trace point AP 0471 is a file control level-1 trace point and AP 0472
is a file control level-2 trace point. These trace points are produced only if the trace
setting for the FC component is “(1,2)” or “ALL”. The component code AP is used
for trace points from the AP domain that do not fall into any of the subcomponent
areas listed above.
Defining component tracing at system initialization: You can code any of the
following parameters to define component tracing at CICS system initialization time:
v SPCTR, to indicate the level of special tracing required for CICS as a whole.
v SPCTRxx, where xx is one of the two-character component identifiers that
specify the level of special tracing you require for a particular CICS component
(see “Component names and abbreviations” on page 238).
v STNTR, to indicate the level of standard tracing required for CICS as a whole.
v STNTRxx, where xx is one of the two-character component identifiers that
specify the level of standard tracing you require for a particular CICS component
(see “Component names and abbreviations” on page 238).
For more information about system initialization parameters, see the CICS System
Definition Guide.
Defining component tracing when the CICS system is running: You can use
the CETR transaction to define component tracing dynamically on the running CICS
system.
v With standard task tracing in effect, from level-1 trace points of all the
components listed.
v With standard task tracing in effect, from level-2 trace points for the 3270 Bridge
component.
v With special task tracing in effect:
– From level-1 trace points only for components DI, EI, IC, and KC
– From both level-1 and level-2 trace points for components AP, CP, DD, DM,
DS, DU, FC, GC, and KE.
No special task tracing is done for components BF, BM, DC, and IS.
You can control the status and certain other attributes of the various types of CICS
tracing either dynamically, using the CETR transaction, or during system
initialization, by coding the appropriate system initialization parameters.
The internal trace table has a minimum size of 16KB, and a maximum size of
1 048 576KB. The table is extendable from 16KB in 4KB increments. You can
change the size of the table dynamically, while CICS is running, but if you do so
you lose all of the trace data that was present in the table at the time of the
change. If you want to keep the data and change the size of the table, take a
system dump before you make the change.
The internal trace table wraps when it is full. When the end of the table is reached,
the next entry to be directed to the internal trace entry goes to the start, and
overlays the trace entry that was formerly there. In practice, the internal trace table
cannot be very big, so it is most useful for background tracing or when you do not
need to capture an extensive set of trace entries. If you need to trace CICS system
activity over a long period, or if you need many entries over a short period, one of
the other trace destinations is likely to be more appropriate.
Note that the internal trace table is always present in virtual storage, whether you
have turned internal tracing on or not. The reason is that the internal trace table is
used as a destination for trace entries when CICS detects an exception condition.
Other trace destinations that are currently selected get the exception trace entry as
well, but the entry always goes to the internal trace table even if you have turned
tracing off completely. This is so that you get “first failure data capture”.
You can use the AUXTR system initialization parameter to turn CICS auxiliary trace
on or off in the system initialization table.
You can select a status of STARTED, STOPPED, or PAUSED for CICS auxiliary
trace dynamically using the CETR transaction. These statuses reflect both the value
of the auxiliary trace flag, and the status of the current auxiliary trace data set, in
the way shown in Table 37.
Table 37. The meanings of auxiliary trace status values
Auxiliary tracing status Auxiliary trace flag Auxiliary trace data set
STARTED ON OPEN
STOPPED OFF CLOSED
PAUSED OFF OPEN
When you first select STARTED for CICS auxiliary trace, any trace entries are
directed to the initial auxiliary trace data set. If CICS terminated normally when
auxiliary trace was last active, this is the auxiliary trace data set that was not being
used at the time. Otherwise, it is the DFHAUXT data set. If you initialize CICS with
auxiliary trace STARTED, DFHAUXT is used as the initial auxiliary trace data set.
What happens when the initial data set is full depends on the status of the auxiliary
switch (AUXTRSW). This can have a value of NO, NEXT, or ALL, and you can
NO means that when the initial data set is full, no more auxiliary tracing is done.
NEXT means that when the initial data set is full, then the other data set receives
the next trace entries. However, when that one is full, no more trace data is written
to auxiliary trace.
ALL means that auxiliary trace data is written alternately to each data set, a switch
being made from one to the other every time the current one becomes full. This
means that trace entries already present in the trace data sets start getting
overwritten when both data sets become full for the first time.
The advantage of using auxiliary trace is that you can collect large amounts of trace
data, if you initially define large enough trace data sets. For example, you might
want to do this to trace system activity over a long period of time, perhaps to solve
an unpredictable storage violation problem.
A time stamp is included in the header line of every page of abbreviated auxiliary
trace output to help match external events with a particular area of the trace, and
thus help you to find the trace entries that are of interest.
You can switch CICS GTF trace on or off by using the GTFTR system initialization
parameter.
You can select a status of STARTED or STOPPED for CICS GTF trace dynamically
using the CETR transaction. MVS GTF trace must be started with the TRACE=USR
option before CICS GTF trace is started, because otherwise no trace entries can be
written.
When the GTF trace data set is full, it wraps. The next trace entries are written at
the start of the data set, and the entries that were formerly there are overlaid. Thus,
you need to define a data set that is big enough to capture all the trace entries that
interest you.
The MVS GTF trace destination can be used not only by CICS, but by other
programs as well. This gives you the opportunity of integrating trace entries from
CICS with those from other programs. A single GTF trace data set could, for
example, contain trace entries made by both CICS and VTAM. You can relate the
two types of trace entry using a unique task identifier in the trace header, known to
both CICS and VTAM.
For more details of system initialization parameters, see the CICS System Definition
Guide.
Setting the tracing status using CETR: You can use the CICS/ESA trace control
transaction (CETR) to set the tracing status. Figure 44 shows you the CETR screen
you can use to set the tracing status dynamically.
In this example, internal tracing status is STOPPED, and so regular tracing is not
CETR CICS/ESA Trace Control Facility
Type in your choices.
Item Choice Possible choices
Internal Trace Status ===> STOPPED STArted, STOpped
Internal Trace Table Size ===> 0016 K 16K - 1048576K
Auxiliary Trace Status ===> PAUSED STArted, STOpped, Paused
Auxiliary Trace Dataset ===> B A, B
Auxiliary Switch Status ===> ALL NO, NExt, All
GTF Trace Status ===> STARTED STArted, STOpped
Master System Trace Flag ===> OFF ON, OFf
Master User Trace Flag ===> OFF ON, OFf
When finished, press ENTER.
PF1=Help 3=Quit 4=Components 5=Ter/Trn 9=Error List
directed explicitly to the internal trace table. However, note that the internal trace
table is used as a buffer for the other trace destinations, so it always contains the
most recent trace entry if at least one trace destination is STARTED. The internal
trace table is also used as a destination for exception trace entries, which are made
whenever CICS detects an exception condition. If such a condition were detected
The internal trace table size is 16KB, which is the minimum size it can be. If internal
trace were STARTED, the trace table would wrap when it became full.
The current auxiliary trace data set is B, meaning that trace entries would be written
to DFHBUXT if auxiliary tracing were started. However, its status is shown to be
PAUSED, so no tracing is done to that destination. The auxiliary switch status is
ALL, so a switch would be made to the other auxiliary trace data set whenever one
became full.
The GTF trace status is shown to be STARTED, which means that CICS trace
entries are written to the GTF trace data set defined to MVS. Be aware that no
error condition is reported if the CICS GTF status is started but GTF tracing has not
been started under MVS. If this happens, the trace entries are not written. The
master system trace flag is OFF. This means that no standard tracing is done at all,
even though standard tracing might be specified for some tasks. However, special
task tracing is not affected—the master system trace flag only determines whether
standard task tracing is to be done.
You can see the role of the master system trace flag in Figure 42 on page 237.
The master user trace flag is OFF, so no user trace entries can be made from
applications. You must set the master user trace flag on before any user trace
requests in your programs can be serviced. If it were off, any trace call requests in
your programs would be ignored.
The logic used to ensure that trace entries are written to the required destinations is
shown in Figure 45 on page 245.
GTF No
tracing status ────────────────]────────────────┐
=STARTED? │
│
│ Yes _
_ │
│
GTF No │
tracing started ───────────────]────────────────┤
under MVS with │
TRACE=USR │
option? │
│
│ Yes │
_ │
┌───────────────────┐ _
│ Trace data copied │ ┌──────┐
│ to the GTF ├─────────────]────────────┤RETURN│
│ trace data set │ └──────┘
└───────────────────┘
Figure 45. How trace entries are directed to the required destinations
You can specify abbreviated, short, or extended trace formatting, to give you
varying levels of information and detail in your output. Typically, abbreviated-format
trace gives you one line of trace per entry; short-format provides two lines of trace
per entry; extended-format provides many lines of trace per entry. The structures of
the different types of trace entry are described in the sections that follow.
Most of the time, the abbreviated trace table is the most useful form of trace
formatting, as you can quickly scan many trace entries to locate areas of interest.
These items of information are often very useful in the diagnosis of problems. By
selecting the short format, you can gain access to this information without having to
bear the processing overhead of formatting a full trace, and without having to deal
with the mass of information in a full trace.
There may be occasions, however, when you need to look at extended format trace
entries, to understand more fully the information given in the corresponding
abbreviated and short entries, and to be aware of the additional data supplied with
many extended trace entries.
Auxiliary trace can be formatted using the CICS trace utility program, DFHTU610.
You can control the formatting, and you can select trace entries on the basis of
task, terminal, transaction, time frame, trace point ID (single or range), dispatcher
task reference, and task-owning domain. This complements the usefulness of
auxiliary trace for capturing large amounts of trace data.
GTF trace can be formatted with the same sort of selectivity as auxiliary trace,
using a CICS-supplied routine with the MVS interactive problem control system
(IPCS).
There are two slightly different extended trace entry formats. One (“old-style”)
resembles the format used in earlier releases of CICS, and gives FIELD A and
FIELD B values. The other (“new-style”) uses a completely new format, described
below.
Figure 46 shows a trace entry made from an old-style trace point. Its trace point ID
is AP 00E1, corresponding to trace ID X'E1' of CICS/MVS Version 2. If you are
migrating from CICS/MVS Version 2, you can probably see the resemblance
between this type of format and the one it replaces.
Note: For some trace entries, an 8 character resource field appears to the right of FIELD B.
Figure 46. Example of the extended format for an old-style trace entry
trace interpretation
point ID string
│ │
┌──┴──┐ ┌─────────────────────────────────────────────┴───────────────────────────────────────────────────┐
SM 0C01 SMMG ENTRY - FUNCTION(GETMAIN) GET_LENGTH(1A4A) SUSPEND(YES) INITIAL_IMAGE(00) STORAGE_CLASS(TASK)
TASK-00163 KE_NUM-0007 TCB-QR /009F3338 RET-800411F2 TIME-16:31:52.5916976250 INTERVAL-00.0000666250 =000112=
1-0000 00480000 00000011 00000000 00000000 B6700000 00000000 02000100 C4C6C8C3 *............................DFHC*
0020 C5E3D9C4 03BD5BB0 00001A4A 03BD5B01 00000001 01000698 04755D70 40400008 *ETRD..$.... ..$........Q..). ..*
0040 00000FE8 C3C5E3D9 *...YCETR *
│ └─┬┘ └──────────────────────────────────┬───────────────────────────────────┘ └───────────────┬──────────────┘
│ │ │ │
│ offset in data any EBCDIC
│ data field characters
│
field 1
Figure 47. Example of the extended format for a new-style trace entry
Abbreviated trace entries show the CICS TCB-ID of the TCB instead of an MVS
TCB address.
Figure 48 gives an example of the abbreviated format for an old-style trace entry.
Note: For some trace entries, an 8-character resource field appears to the right of FIELD B.
Figure 48. Example of the abbreviated format for an old-style trace entry
Abbreviated old-style trace entries are easy to interpret, as you can readily identify
the REQ, FIELD A and FIELD B fields. Note that some such trace entries also
include a RESOURCE field.
For ZCP trace entries, FIELD B (which contains the TCTTE address) is printed
twice on each line. This allows both sides of the output to be scanned for the
terminal entries on an 80-column screen without having to scroll left and right.
Figure 49 gives an example of the abbreviated format for a new-style trace entry.
abbreviated
task trace interpretation
number point ID string
│ │ │
┌─┴─┐ ┌──┴──┐ ┌─────────────────────────────────┴────────────────────────────────────────────────────┐
00021 QR LD 0002 LDLD EXIT ACQUIRE_PROGRAM/OK 03B8A370 , 00000001,848659C0,048659A0,410,200,REUSABLE =000023=
└──┬──┘ └──┬───┘
│ │
TCB ID trace entry
number
Figure 49. Example of the abbreviated format for a new-style trace entry
Abbreviated-format new-style trace entries are less readily interpreted, because the
parameters in the interpretation string are not identified by name. If you are not
familiar with the parameters included in the trace entry, you need to look at the
trace interpretation
point ID string
│ │
┌──┴──┐ ┌──────────────────────────────────────────────────────────┴─────────────────────────────────────────────────────────────┐
LD 0002 LDLD EXIT - FUNCTION(ACQUIRE_PROGRAM) RESPONSE(OK) NEW_PROGRAM_TOKEN(03B8A370 , 00000001) ENTRY_POINT(848659C0) LOAD_POINT
(048659A0) PROGRAM_LENGTH(410) FETCH_TIME(200) PROGRAM_ATTRIBUTE(REUSABLE)
TASK-00021 KE_NUM-0007 TCB-QR /009FF3C0 RET-847B26A2 TIME-10:45:49.6888118129 INTERVAL-00.0000235625 =000023=
1-0000 00880000 0000001C 00000000 00000000 BBA02800 00000000 01000100 C4C6C8C3 *.h..........................DFHC*
0020 D9D84040 FD052000 00062060 03B8A370 00000001 848659C0 048659A0 A4F78696 *RQ .......-..t.....df...f..u7fo*
0040 00000410 C3D9E2D8 00000000 C3C9C3E2 E4E2C5D9 01010002 1C000000 00000000 *....CRSQ....CICSUSER............*
0060 00000000 00000200 C302D840 40000500 01000000 00000000 00000000 00000000 *........C.Q ...................*
0080 00000000 00000000 *........ *
│ └─┬┘ └──────────────────────────────────┬───────────────────────────────────┘ └───────────────┬──────────────┘
│ │ │ │
│ offset in data any EBCDIC
│ data field characters
│
field 1
LD 0002 shows that this trace entry was made from trace point X'0002' in the
loader domain.
The data displayed below the standard information was taken from only one data
area. If you look in the CICS User’s Handbook for details of trace point ID LD 0002,
you will see that the data area is the LDLD parameter list.
Figure 51 on page 252 shows an example of the short-format for an old-style entry.
00030 QR AP 00E1 EIP ENTRY INQUIRE-TRACEFLAG REQ(0004) FIELD-A(071F6018 ..-.) FIELD-B(08007812 ....)
Extended format user trace entries show a user-defined resource field, and a
user-supplied data field that can be up to 4000 bytes in length. A typical
extended-format entry is shown in Figure 53.
trace interpretation
point ID string
│ │
┌──┴──┐ ┌─────────────────────────────────────────────┴─────────────────────────────────────────────────────┐
AP 000B USER EVENT - APPLICATION-PROGRAM-ENTRY - SEND - CICS USER TRACE ENTRY HELP INFORMATION
TASK-00163 KE_NUM-0007 TCB-QR /009F3338 RET-8003F54C TIME-16:32:01.1295568750 INTERVAL-00.0001965625 =000731=
1-0000 E4E2C5D9 404040 *USER *
2-0000 C3C9C3E2 40E4E2C5 D940E3D9 C1C3C540 C5D5E3D9 E8404040 40404040 40404040 *CICS USER TRACE ENTRY *
0020 C8C5D3D7 40C9D5C6 D6D9D4C1 E3C9D6D5 40404040 40404040 40404040 40404040 *HELP INFORMATION *
0040 40404040 40404040 40404040 40404040 40404040 40404040 40404040 40404040 * *
0060 40404040 40404040 40404040 40404040 40404040 40404040 40404040 40404040 * *
3-0000 E2C5D5C4 40404040 *SEND *
│ └─┬┘ └──────────────────────────────────┬───────────────────────────────────┘ └───────────────┬──────────────┘
│ │ │ │
│ offset in data any EBCDIC
│ data field characters
│
data field
number
Figure 53. Example of the extended format for a user trace entry
The interpretation string for the entry contains the string “APPLICATION-
PROGRAM-ENTRY”, to identify this as a user trace entry, and the resource field.
abbreviated
task trace interpretation optional
number point ID string user data
│ │ │ │
┌─┴─┐ ┌──┴──┐ ┌─────────────────────┴──────────────────────┐ ┌──────────────────────┴─────────────────────────────┐
00163 QR AP 000B USER EVENT APPLICATION-PROGRAMRY SEND CICS USER TRACE ENTRY HELP INFORMATION =000731=
└──┬─┘ └──┬───┘
│ │
TCB ID trace entry
number
Figure 54. Example of the abbreviated format for a user trace entry
Abbreviated-format trace entries show the user resource field in the interpretation
string. There is also an optional user data field that contains as much user-specified
data as can be fitted into the line. If successive user trace entries have the same
resource field value, but different data field values, you might need to see the
corresponding extended trace entries to assess their significance. Figure 55 shows
an example of the short format for a user trace entry.
└──┬──┘ └──┬───┘
trace call return
point ID address
Figure 55. Example of the short format for a user trace entry
The type of dump to use for problem determination depends on the nature of the
problem. In practice, the system dump is often more useful, because it contains
more information than the transaction dump. You can be reasonably confident that
the system dump has captured all the evidence you need to solve your problem,
but it is possible that the transaction dump might have missed some important
information.
The amount of CICS system dump data that you could get is potentially very large,
but that need not be a problem. You can leave the data on the system dump data
set, or keep a copy of it, and format it selectively as you require.
You can control the dump actions taken by CICS, and also what information the
dump output contains.
Each CICS system dump header includes a symptom string. The symptom string
will be created only if the system dump code has the DAE option specified in the
dump table entry. The default action is that symptom strings are not produced. This
can, however, be altered by means of the DAE= system initialization parameter.
On most occasions when dumps are requested, CICS references a dump code that
is specified either implicitly or explicitly to determine what action should be taken.
Dump codes are held in two dump tables, the transaction dump table and the
system dump table.
You might use these methods of taking dumps if, for example, you had a task in a
wait state, or you suspected that a task was looping. However, these methods are
not useful for getting information following a transaction abend or a CICS system
abend. This is because the evidence you need is almost certain to disappear before
your request for the dump has been processed.
7. To make PL/I on units work, PL/I library routines can issue HANDLE ABEND. This is called an implicit HANDLE ABEND and
causes the suppression of transaction dumps.
Before CICS for MVS/ESA 4.1, such automatic and simultaneous dump data
capture of CICS data was impossible.
You need MVS/ESA 5.1, the MVS workload manager, and the XCF facility in order
to collect dump data in this way. The MVS images in the sysplex must be
connected via XCF. The CICS regions must be using MRO supported by the CICS
Transaction Server for z/OS, Version 2 Release 1 interregion communication
program, DFHIRP.
The CICS regions must be connected via XCF/MRO. Connections using VTAM ISC
are not eligible to use the related dump facility.
The function is controlled by the DUMPSCOPE option on each CICS dump table
entry. You can set this option to have either of the following values:
v RELATED - take dumps for all related CICS regions across the sysplex.
v LOCAL - take dumps for the requesting CICS region only. This is the default.
The DUMPSCOPE option is available on the following master terminal and system
programming commands:
v EXEC CICS INQUIRE SYSDUMPCODE
v EXEC CICS SET SYSDUMPCODE
v EXEC CICS INQUIRE TRANDUMPCODE
v EXEC CICS SET TRANDUMPCODE
v CEMT INQUIRE SYDUMPCODE
v CEMT SET SYDUMPCODE
v CEMT INQUIRE TRDUMPCODE
v CEMT SET TRDUMPCODE
If the DUMPSCOPE option is set to RELATED in the CICS region issuing the dump
request, a request for a system dump is sent to all MVS images in the sysplex that
run related CICS regions.
When a dump is requested, the DUMPSCOPE option is tested only in the CICS
region issuing the original dump request. If the requesting CICS region has
DUMPSCOPE defined as RELATED for the dump code, then all related CICS
regions are dumped even if they have DUMPSCOPE defined as LOCAL for the
dump code.
There is a maximum of fifteen address spaces in an SDUMP. If there are more than
fifteen related CICS regions on an MVS image, then not all of them will be dumped.
Related CICS regions may also fail to be dumped if they are swapped out when the
dump request is issued. You should consider whether to make certain CICS regions
non-swappable as a result.
Without this facility, such simultaneous dump data capture across multiple CICS
regions in the sysplex is impossible.
where:
v REMOTE controls the issuing of dumps on remote systems.
v SYSLIST=* means the request is to be routed to all remote systems.
v PROBDESC is problem description information, as follows:
– SYSDCOND - an MVS keyword. This specifies that a dump is to be taken on
remote MVS images if the IEASDUMP.QUERY exit responds with return code
0. CICS supplies DFHDUMPX as the IEASDUMP.QUERY exit.
– SYSDLOCL - an MVS keyword. This drives the IEASDUMP.QUERY exit on
the local and remote MVS images. This allows the CICS regions on the local
MVS region to be dumped.
– DFHJOBN - a CICS keyword. The operator should include the generic job
name. This is used by DFHDUMPX to determine which address spaces to
dump.
See the MVS System Commands manual, GC28-1626, for a full description of all
command options.
If you adopt a suitable naming convention for your CICS regions, this can be used
to define suitable generic jobnames to determine which CICS regions to dump. See
the System/390 MVS Sysplex Application Migration manual for recommendations on
naming conventions. If you follow the recommendation in this manual, the generic
job name for all CICS regions in the sysplex would be ‘CICS*’.
Note: You can use the CONT option to split this command into parts, as follows:
/R nn,JOBNAME=(CICS-job-name,SMSVSAM,CATALOG,GRS), CONT
/R nn,DSPNAME='SMSVSAM'.*,REMOTE=(SYSLIST=*('SMSVSAM', CONT
/R nn,'CATALOG','GRS'),DSPNAME,SDATA, END
If you are unable to produce related system dumps when there are related CICS
regions across MVS images, ensure that the regions are MRO connected.
Use CEMT I IRC to ensure that interregion communication is available. If IRC is not
available it may be started using the CEMT S IRC OPEN command. Failure to start
IRC results in DFHIRxxx messages which may be used to identify the source of the
problem.
During IRC start processing, CICS attempts to join XCF group DFHIR000. If this
fails, return code yyy is given in the DFHIR3777 message.
The following MVS console commands may be used to monitor activity in the
sysplex:
v D XCF - to identify the MVS sysplex and list the name of each MVS image in the
sysplex.
An example of a response to this command looks like this:
08.14.16 DEV5 d xcf
08.14.16 DEV5 IXC334I 08.14.16 DISPLAY XCF 602
SYSPLEX DEVPLEX5: DEV5
This response tells you that MVS image DEV5 has joined sysplex DEVPLEX5.
v D XCF,GROUP - to list active XCF groups by name and size (note that CICS, group
DFHIR000, is missing from the following example response).
This example also indicates that the primary and alternate data sets are on the
same volume, thereby giving rise to a single point of failure.
Use the CICS master terminal command CEMT I CONNECTION to display the
status of the connections. ‘XCF’ is displayed for every acquired connection using
MRO/XCF for communications.
I CONNECTION
STATUS: RESULTS - OVERTYPE TO MODIFY
Con(FORD) Net(IYAHZCES) Ins Acq Xcf
Con(F100) Net(IYAHZCEC) Ins Acq Irc
Con(F150) Net(IYAHZCED) Ins Acq Irc
Con(GEO ) Net(IYAHZCEG) Ins Acq Xcf
Con(GMC ) Net(IYAHZCEB) Ins Acq Xcf
Con(JIM ) Net(IYAHZCEJ) Ins Acq Xcf
Con(MARY) Net(IYAHZCEM) Ins Acq Xcf
Con(MIKE) Net(IYAHZCEI) Ins Acq Xcf
+ Con(RAMB) Net(IYAHZCEE) Ins Acq Xcf
SYSID=CHEV APPLID=IYAHZCET
RESPONSE: NORMAL TIME: 01.28.59 DATE: 06.11.94
PF 1 HELP 3 END 7 SBH 8 SFH 9 MSG 10 SB 11 SF
If you have determined that XCF communication is in use, you can verify that the
CICS SDUMP exit has been established using the following MVS commands:
D PROG,EXIT,MODNAME=DFHDUMPX
08.16.04 DEV5 CSV463I MODULE DFHDUMPX IS NOT ASSOCIATED ANY EXIT
D PROG,EXIT,EN=IEASDUMP.QUERY
08.17.44 DEV5 CSV463I NO MODULES ARE ASSOCIATED WITH EXIT IEASDUMP.QUERY
D PROG,EXIT,EN=IEASDUMP.QUERY
01.19.46 DEV5 CSV462I 01.19.46 PROG,EXIT DISPLAY 996
MODULE DFHDUMPX
EXIT(S) IEASDUMP.QUERY
You may issue MVS dump commands from the console to verify that remote
dumping is available within the MVS image, without an active CICS region.
11.29.59 DEV5 dump comm=(NO CICS)
11.29.59 DEV5 *03 IEE094D SPECIFY OPERAND(S) FOR DUMP COMMAND
11.36.49 DEV5 r 03,remote=(syslist=*),probdesc=(sysdcond,
sysdlocl,(dfhjobn,iyahzcet))
11.36.49 DEV5 IEE600I REPLY TO 03 IS;REMOTE=(SYSLIST=*),
PROBDESC=(SYSDCOND,SYSDL
11.36.52 DEV5 IEA794I SVC DUMP HAS CAPTURED:
DUMPID=001 REQUESTED BY JOB (*MASTER*)
DUMP TITLE=NO CICS
In the next example, the messages from SDUMP indicate that one dump of the
master address space has been taken.
*11.37.03 DEV5 *IEA911E COMPLETE DUMP ON SYS1.DUMP03
*DUMPID=001 REQUESTED BY JOB (*MASTER*)
*FOR ASID (0001)
*REMOTE DUMPS REQUESTED
*INCIDENT TOKEN: DEVPLEX5 DEV5 06/28/1994 11:36:49
Another test is to issue the dump command specifying the CICS XCF group.
11.42.33 DEV5 dump comm=(STILL NO CICS)
11.42.33 DEV5 *05 IEE094D SPECIFY OPERAND(S) FOR DUMP COMMAND
11.43.27 DEV5 r 05,remote=(grplist=dfhir000(*)),
probdesc=(sysdcond,sysdlocl,(dfhjobn,iyahzcet))
11.43.28 DEV5 IEE600I REPLY TO 05
IS;REMOTE=(GRPLIST=DFHIR000(*)),PROBDESC=(SYSD
11.43.31 DEV5 IEA794I SVC DUMP HAS CAPTURED:
DUMPID=002 REQUESTED BY JOB (*MASTER*)
DUMP TITLE=STILL NO CICS
The messages from SDUMP indicate that one dump of the master address space
has been taken.
*11.43.42 DEV5 *IEA911E COMPLETE DUMP ON SYS1.DUMP03
*DUMPID=002 REQUESTED BY JOB (*MASTER*)
*FOR ASID (0001)
*REMOTE DUMPS REQUESTED
*INCIDENT TOKEN: DEVPLEX5 DEV5 06/28/1994 11:43:28
To verify that the remote dumping function works on the local system, use the
following commands:
11.45.57 DEV5 dump comm=(TEST REMOTE FUNCTION ON LOCAL SYSTEM
11.45.57 DEV5 *06 IEE094D SPECIFY OPERAND(S) FOR DUMP COMMAND
11.46.57 DEV5 r 06,remote=(grplist=*(*)),probdesc=(sysdlocl)
11.46.59 DEV5 IEE600I REPLY TO 06 IS;REMOTE=(GRPLIST=*(*)),
PROBDESC=(SYSDLOCL)
The messages from SDUMP indicate two dumps were taken, one for the master
address space and a second which contains ASIDs 0101, 0012, 0001, 0005, 000B,
000A, 0008, 0007. Note that the same incident token is used for both dumps.
*11.47.39 DEV5 *IEA911E COMPLETE DUMP ON SYS1.DUMP03
*DUMPID=003 REQUESTED BY JOB (*MASTER*)
*FOR ASID (0001)
*REMOTE DUMPS REQUESTED
*INCIDENT TOKEN: DEVPLEX5 DEV5 06/28/1994 11:46:57
*11.47.59 DEV5 *IEA911E COMPLETE DUMP ON SYS1.DUMP04
*DUMPID=004 REQUESTED BY JOB (DUMPSRV )
*FOR ASIDS(0101,0012,0005,0001,000A,000B,0008,0007)
*REMOTE DUMP FOR SYSNAME: DEV5
*INCIDENT TOKEN: DEVPLEX5 DEV5 06/28/1994 11:46:57
The following example lists the MVS console messages received when the CICS
master terminal command CEMT P DUMP is issued from CICS APPLID IYAHZCET
executing in ASID 19 on MVS image DEV6. IYAHZCET has at least one related
task in the CICS region executing in ASID 1B on MVS DEV6 and ASIDS 001A,
001C, 001B, 001E, 001F, 0020, 001D, 0022, 0024, 0021, 0023, 0028, 0025, 0029,
0026 on MVS image DEV7.
- 22.19.16 DEV6 JOB00029 +DFHDU0201 IYAHZCET ABOUT TO TAKE SDUMP. DUMPCODE: MT0001
- 22.19.23 DEV7 DFHDU0214 DFHDUMPX IS ABOUT TO REQUEST A REMOTE SDUMPX.
- 22.19.23 DEV6 DFHDU0214 DFHDUMPX IS ABOUT TO REQUEST A REMOTE SDUMPX.
22.19.27 DEV6 JOB00029 IEA794I SVC DUMP HAS CAPTURED:
DUMPID=001 REQUESTED BY JOB (IYAHZCET)
DUMP TITLE=CICS DUMP: SYSTEM=IYAHZCET CODE=MT0001 ID=1/0001
- 22.19.43 DEV6 JOB00029 +DFHDU0202 IYAHZCET SDUMPX COMPLETE. SDUMPX RETURN CODE X'00'
The dump in SYS1.DUMP03 on DEV6 was taken as a result of the CEMT request
on IYAHZCET.
*22.21.15 DEV6 *IEA911E COMPLETE DUMP ON SYS1.DUMP04
*DUMPID=002 REQUESTED BY JOB (DUMPSRV )
*FOR ASIDS(0019,001B)
*REMOTE DUMP FOR SYSNAME: DEV6
*INCIDENT TOKEN: DEVPLEX1 DEV6 06/10/1994 22:19:16
*ID = DUMP : APPLID IYAHZCET DUMPCODE MT0001 /1/0001
The dump in SYS1.DUMP04 on DEV6 was taken as a remote dump by MVS dump
services as a result of the CEMT request on IYAHZCET. Note that the incident
token and ID are the same.
22.22.35 DEV7 JOB00088 IEA794I SVC DUMP HAS CAPTURED:
DUMPID=003 REQUESTED BY JOB (DUMPSRV )
DUMP TITLE=CICS DUMP: SYSTEM=IYAHZCET CODE=MT0001 ID=1/0001
The dump in SYS1.DUMP05 on DEV7 was taken as a remote dump by MVS dump
services as a result of the CEMT request on IYAHZCET. Note that the incident
token and ID are the same as those for the dumps produced on DEV6, indicating
the originating MVS and CICS IDs.
The following example lists the MVS console messages received when transaction
abend SCOP is initiated after having first been added to the transaction dump table
in CICS IYAHZCES as requiring related dumps. (CEMT S TRD(SCOP) ADD
RELATE).
CICS IYAHZCES (ASID 1A in MVS DEV7) has at least one related task in CICS
IYAHZCET (ASID 19 in MVS DEV6).
23.40.41 DEV7 JOB00088 +DFHDU0201 IYAHZCES ABOUT TO TAKE SDUMP. DUMPCODE: SCOP
23.40.49 DEV7 DFHDU0214 DFHDUMPX IS ABOUT TO REQUEST A REMOTE SDUMPX.
23.40.55 DEV7 JOB00088 IEA794I SVC DUMP HAS CAPTURED:
23.41.11 DEV7 JOB00088 +DFHDU0202 IYAHZCES SDUMPX COMPLETE. SDUMPX RETURN CODE X'00'
The dump in SYS1.DUMP03 on DEV6 was taken upon receipt of the remote dump
request issued from IYAHZCES. Note the incident token and ID are the same as
those for dumps produced on DEV7.
*23.41.28 DEV7 *IEA911E COMPLETE DUMP ON SYS1.DUMP03
*DUMPID=012 REQUESTED BY JOB (IYAHZCES)
*FOR ASID (001A)
*REMOTE DUMPS REQUESTED
*INCIDENT TOKEN: DEVPLEX1 DEV7 06/10/1994 23:40:41
*ID = DUMP : APPLID IYAHZCES DUMPCODE SCOP /1/0008
The dump in SYS1.DUMP04 on DEV7 was taken as a remote dump by MVS dump
services as a result of the request from IYAHZCES. Note the incident token and ID
are the same as those for the dumps produced on DEV6, indicating the originating
MVS and CICS IDs. A second dump of ASID 1A is taken because the CICS
IEASDUMP does not have information indicating that a dump has already been
taken for that address space.
To determine which messages you can do this for, look in the CICS Messages and
Codes manual. If the message you are interested in has a 2-character alphabetic
component ID after the “DFH” prefix, and it has either XMEOUT global user exit
parameters or a destination of “Terminal User”, you can use it to construct a system
dump code to add to the dump table.
You cannot enable dumping for messages that do not have these characteristics.
For example, some messages that are issued early during initialization cannot be
used to cause CICS to take a system dump, because the mechanisms that control
dumping might not be initialized at that time. Also, you cannot enable dumping for
the message domain’s own messages (they are prefixed by “DFHME”) where they
do not normally cause CICS to take a system dump.
If the code had been running in user key at the time of the program check or MVS
abend, CICS issues message DFHSR0001 and takes a system dump with dump
code SR0001. Only application programs defined with EXECKEY(USER) run in
user key.
If the code had not been running in user key at the time of the program check or
MVS abend, CICS issues message DFHAP0001 and takes a system dump with
dump code AP0001.
So, if CICS storage protection is active, this mechanism enables you to suppress
the system dumps caused by errors in application programs, while still allowing
dumps caused by errors in CICS code to be taken. To achieve this, use either a
If storage protection is not active, the dumps may be suppressed via a suppression
of dumpcode AP0001. Note, however, that this suppresses dumps for errors in both
application and CICS code. The XDUREQ global user exit can be used to
distinguish between AP0001 situations in application and nonapplication code.
You cannot control AP0001 and SR0001 system dumps by using the DUMP
parameter of the TRANSACTION resource definition. The DUMP parameter of the
TRANSACTION resource definition controls only transaction dumps.
adds an entry to the dump table and ensures that SDUMPs are taken for ASRB
abends. However, note that the SDUMP in this instance is taken at a later point
than the SDUMP normally taken for system dump code AP0001 or SR0001.
The only circumstances in which dump table additions and changes are lost are:
v When CICS is cold started.
v When the CICS global catalog is redefined, although this is likely to be done only
in exceptional circumstances.
v When CICS creates a temporary dump table entry for you, because you have
asked for a dump for which there is no dump code in the dump table.
v Example 1 shows a transaction dump table entry for transaction dump code
MYAB. This is a user-supplied dump code, specified either on an
EXEC CICS DUMP TRANSACTION command, or as a transaction abend code
on an EXEC CICS ABEND command.
The table entry shows that when this dump code is invoked, both a transaction
dump and a system dump are to be taken, and CICS is not to be terminated.
System dumps on related systems are not to be taken. The dump code action
can be taken a maximum of 50 times, but the action for this dump code has not
been taken since CICS was started or since the current count (“times dump
action taken”) was reset.
v Example 2 shows a transaction dump table entry for transaction dump code
ASRA. This is a CICS transaction abend code, and this dump table entry is
referred to every time a transaction abends ASRA. The entry shows that a
system dump only is to be taken for an ASRA abend, and that CICS is not to be
terminated. System dumps on related systems are to be taken. It also shows that
the action for this abend code has already been taken the maximum number of
times, so no action is taken when another ASRA abend occur. However, the
current count could be reset to 0 dynamically using either a CEMT transaction or
a system programming command (SET TRANDUMPCODE or SET
SYSDUMPCODE). More system dumps would then be taken for subsequent
ASRA abends.
Table 39 shows how the transaction dump table entry for transaction dump code
MYAB would be updated with and without global suppression of system dumping.
Only the updated fields are shown.
Table 39. Effect of global suppression of system dumping on transaction dump table update
Type of information Before update System dumping System dumping
enabled suppressed
Transaction dump code MYAB
Take a transaction dump? YES
Take a system dump? YES
| Take system dumps on NO
| related systems?
Shut down CICS? NO
Maximum times action can 50
be taken
Times action already 0 1 1
taken
Transaction dumps taken 0 1 1
Transaction dumps 0 0 0
suppressed
System dumps taken 0 1 0
System dumps 0 0 1
suppressed
The statistics show that a system dump was taken when system dumping was
enabled, but not when system dumping was suppressed.
There is a further effect. CICS maintains a record of the current dump ID—the
number of the most recent dump to be taken. This is printed at the start of the
dump, together with the appropriate dump code. It is concatenated with the CICS
run number—that is, the number of times that CICS has been brought up since the
global catalog was created—to provide a unique ID for the dump.
Note: This does not apply to SDUMPs taken by the kernel; these always have a
dump ID of 0/0000.
For example, for the ninth dump to be taken during the eleventh run of CICS, if the
dump code were TD01, this is what you would see:
CODE=TD01 ID=11/0009
The sort of information kept in the system dump table is similar to that kept in the
transaction dump table (see Table 38 on page 268).
v Example 1 shows a system dump table entry for system dump code SYDMP001,
a user-supplied system dump code, specified using EXEC CICS PERFORM
DUMP. System dumps on related systems are to be taken. Dumps duplicate of
this one are to be suppressed by DAE. The table entry shows that no dumps
have yet been taken. However, if one were taken, CICS would be shut down. If
global suppression of system dumping was in effect, no dump would be taken
but CICS would be shut down if this dump code were referenced.
v Example 2 shows the system dump table entry for system dump code MT0001,
the CICS-supplied dump code for system dumps requested from the master
terminal, with CEMT PERFORM DUMP or CEMT PERFORM SNAP. CICS is not
shut down when a dump is taken for this dump code. Also, the value of 999 for
“maximum times action can be taken” shows that an unlimited number of dumps
can be taken for this dump code. The current count (“times action already taken”)
shows that to date, 79 dumps have been requested using CEMT.
The default value used for the DAEOPTION attribute (for all new system dump
codes) is set by means of the DAE= system initialization parameter. The default
value for the maximum number of times that the dump action can be taken is set by
You can modify the default values for a transaction dump table entry using the
following commands:
v CEMT SET TRDUMPCODE
v EXEC CICS SET TRANDUMPCODE
v EXEC CICS SET TRANSACTION DUMPING (to modify the TRANDUMPING
attribute only).
The following table shows the default values for transaction dump table entries and
the attributes you can specify to modify them:
Table 41. Default values for transaction dump table entries
Action Default Attribute Permitted value
Take a transaction YES TRANDUMPING TRANDUMP or
dump? NOTRANDUMP
Take a system dump? NO SYSDUMPING SYSDUMP or
NOSYSDUMP
Take system dumps on NO DUMPSCOPE LOCAL or RELATED
related systems?
Shut down CICS? NO SHUTOPTION SHUTDOWN or
NOSHUTDOWN
Maximum times dump 999 MAXIMUM 0 through 999
code action can be
taken
You can modify the default values for a system dump table entry using the following
commands:
v CEMT SET SYDUMPCODE
v EXEC CICS SET SYSDUMPCODE
v EXEC CICS SET SYSTEM DUMPING (to modify the SYSDUMPING attribute
only).
The following table shows the default values for system dump table entries and the
attributes you can specify to modify them:
Table 42. Default values for system dump table entries
Action Default Attribute Permitted value
Take a system dump? YES SYSDUMPING SYSDUMP or
NOSYSDUMP
Take system dumps on NO DUMPSCOPE LOCAL or RELATED
related systems?
Shut down CICS? NO SHUTOPTION SHUTDOWN or
NOSHUTDOWN
Is dump eligible for NO DAEOPTION DAE or NODAE
DAE?
Maximum times dump 999 MAXIMUM 0 through 999
code action can be
taken
CICS makes a temporary dump table entry for dump code SYDMPX01, and you
can browse it, and see that it has the default attributes for a system dump code.
You can also see that the current count has been set to 1, as a dump has been
taken.
Attempting to add the dump code to the dump table after CICS has made the entry
causes the exception response ‘DUPREC’ to be returned. If you want to make a
change to the CICS-generated default table entry, and have that entry preserved
across CICS runs, you must delete it and then add a new entry with the options you
require.
When CSFE ZCQTRACE is enabled, a dump of the builder parameter set and the
appropriate TCTTE is written to the transaction dump data set at specific points in
the processing. Table 43 shows the circumstances in which dumps are invoked, the
modules that invoke them, and the corresponding dump codes.
Table 43. ZCQTRACE dump codes
Module Dump code When invoked
DFHTRZCP AZCQ Installing terminal when termid = terminal ID
DFHTRZZP AZQZ Merging terminal with TYPETERM
when termid = terminal ID
DFHTRZXP AZQX Installing connection
when termid = connection ID
DFHTRZIP AZQI Installing sessions
when termid = connection ID
DFHTRZPP AZQP When termid = pool terminal ID
DFHZCQIQ AZQQ Inquiring on resource when termid = resource ID
(resource = terminal or connection)
DFHZCQIS AZQS Installing a resource when termid = resource ID
(resource = terminal or connection), or when
ZCQTRACE,AUTOINSTALL is specified.
Looking at dumps
CICS system dumps and transaction dumps are written unformatted to the
appropriate dump data set. In other words, they are memory dumps of all or part of
the CICS address space.
The formatting options that are available for transaction dumps and system dumps
are described in Formatting transaction dumps and “Formatting system dumps” on
page 280, respectively.
You can also use the SCAN option with the dump utility program, to get a list of the
transaction dumps recorded on the specified dump data set.
For information about using DFHDU610 to format transaction dumps, see the CICS
Operations and Utilities Guide.
Job log
The job log for the dump utility program, DFHDU610, is sometimes shown at the
start of the transaction dump, depending on how the job was invoked. You can
ignore it, because it does not contain any information that can be used for
debugging.
Symptom string
The symptom string tells you something about the circumstances of the transaction
dump. It might show, for example, that the dump was taken because the transaction
abended with abend code ASRA.
If you refer the problem that caused the dump to be taken to the IBM Support
Center, they can use the symptom string to search the RETAIN database for
problems that resemble it.
PSW
If the transaction dump was taken in response to a local abend with abend code
AICA, ASRA, ASRB, or ASRD, a PSW is formatted from the dump data set. It
belongs to the program that was being executed when the abend occurred. It is
taken from the transaction abend control block (see “Transaction storage” on
page 276).
Execution key
If the transaction abended locally with abend code ASRA or ASRB, the execution
key that is in force at the time of the abend is formatted. It is taken from the
transaction abend control block (see “Transaction storage” on page 276).
Space
If the transaction abended locally with an ASRA or ASRB abend code, CICS
formats the space, basespace or subspace, in which the program was executing. If
transaction isolation is not enabled, the program always executes in the basespace.
Provided that you had EI level-1 and PC level-1 tracing selected for your task, you
can identify the last CICS command issued by your task quite easily. The procedure
is outlined in “Locating the last command or statement” on page 278.
Transaction storage
“Transaction storage” is storage that might have been obtained by CICS to store
information about a transaction, or it might have been explicitly GETMAINed by the
transaction for its own purposes. You are likely to find several such areas in the
dump, each introduced by a header describing it as transaction storage of a
particular class, for example:
USER24
USER31
CICS24
To look at the TIOA for the task, find the address in field TCTTEDA of the TCTTE.
Other program manager control blocks are shown too, including PPT entries for
active programs, and load list elements and program storage for any programs
loaded by this transaction but not yet released.
Module index
The final item that you find in the transaction dump is the module index. This shows
you all the modules that were in storage when the error was detected, and their
addresses.
If you did not have trace running, you need to rely on values in registers belonging
to your programs, and try to relate these to your source statements. That might lead
you to an EXEC CICS command, or to another type of statement in your program.
The procedure is outlined in “Last statement identification”.
You need to look in the appropriate programming language manual for details of the
structure of the program’s acquired storage.
Register Use
3 In most circumstances, is the base register
12 Holds the address of the CICS TCA for the C/370 program
13 Holds the address of the register save area
For each invocation of the COBOL program, CICS copies the static TGT from
program storage into CICS dynamic storage (the COBOL area) and uses the
dynamic copy instead of the static one. CICS also copies working storage from
program storage to the COBOL area, above the TGT. Task-related COBOL areas
thus enable the single copy of a COBOL program to multithread as if it were truly
reentrant.
The TGT is used to hold intermediate values set at various stages during program
execution. The first 18 words of the TGT constitute a standard save area, in which
the program’s current registers are stored on any request for CICS service.
The TGT also holds the base locator for linkage (BLL) cells, which contain the
addresses of all areas defined in the linkage section of the COBOL program. You
can use the memory map from the COBOL compiler listing for your application to
find the offset of the BLL cells in the TGT.
The first BLL cell that is used points to the EXEC interface block (an area that
follows the literal string 'DFHEIB').
The second BLL cell that is used points to the first (or only) 4096-byte block of
CICS COMMAREA as supplied with an EXEC CICS LINK, XCTL, or RETURN with
a TRANSID. If the COMMAREA is greater than 4096 bytes, the third BLL cell that
is used points to the next 4096-byte block of COMMAREA; further 4096-byte
COMMAREAs are pointed to by succeeding BLL cells.
The next BLL cell always points to itself; the remaining BLL cells are set by the
application program. Thus, for example, if the COMMAREA size is 10KB, it is the
fifth BLL cell used that points to itself.
Note that an ASRD abend will occur if an attempt is made to access storage via the
BLL cell immediately after the one that points to itself, if it has not yet been set by
the application program.
In prior releases, the CICS formatting routine for use under the MVS interactive
problem control system (IPCS) is supplied as DFHPDX. This standard name is not
Ensure that the CICS-supplied DFHIPCSP member can be found by your IPCS job.
You can either copy DFHIPCSP into SYS1.PARMLIB (so that it is in the same
default library as BLSCECT) or provide an IPCSPARM DD statement to specify the
library containing the IPCS control tables. For example:
//IPCSPARM DD DSN=SYS1.PARMLIB,DISP=SHR For BLSCECT
// DD DSN=CICSTS21.CICS.SDFHPARM,DISP=SHR For DFHIPCSP
The use of formatting keywords enables you to format those parts of the dump that
interest you at any particular time, at specific levels of detail. You have the option of
formatting other parts later for further investigation by you or by the IBM service
organizations. It is advisable to copy your dumps so that you can save the copy
and free the dump data set for subsequent use.
For guidance about using the formatting keywords and levels, see the CICS
Operations and Utilities Guide.
If you omit all of the component keywords, and you do not specify DEF=0, the
CICS dump exit formats dump data for all components.
The CICS dump component keywords, and the levels you can specify for each of
them, are as follows:
AI [={0|2}]
Autoinstall model manager.
AI=0 Suppress formatting of AI control blocks.
AI=2 Format AI control blocks.
AP [={0|1|2|3}]
Application domain.
AP=0 Suppress formatting of AP control blocks.
AP=1 Format a summary of addresses of the AP control blocks for each
active transaction.
AP=2 Format the contents of the AP control blocks for each active
transaction.
AP=3 Format level-1 and level-2 data.
APS=<TASKID=Task identifier>
Application selection. The APS component keyword allows you to limit
Note: You must use angled brackets around the specified parameter.
AU [={0|2}]
CICS affinities utility.
AU=0 Suppress formatting of AU control blocks.
AU=2 Format the affinities utility control blocks (the GWA, and the internal
trace table).
BA [={0|1|2|3}]
Business application manager domain.
BA=0 Suppress formatting of business application manager domain control
blocks.
BA=1 Format the BA unit of work context (BAUW) and BA activity (BAACT)
summaries.
BA=2 Format the anchor block (BADMANC), BA unit of work context (BAUW),
and BA activities (BAACT).
BA=3 Format level-1 and level-2 data.
BR [={0|1|2|3}]
The 3270 bridge
BR=0 Suppress formatting of bridge control blocks.
BR=1 Format bridge facility summary information.
BR=2 Format the bridge exit interface block, the bridge facility block, the
bridge facility bitmap and keep chain, and the TXN_CS.
BR=3 Format level-1 and level-2 data.
CC [={0|2}]
The CICS catalog domain.
CC=0 Suppress formatting of CC control blocks.
CC=2 Format the CC control blocks.
CP [={0|2}]
The common programming interface.
CP=0 Suppress formatting of CP control blocks.
CP=2 Format the CPI static storage.
CSA[={0|2}]
The CICS common system area.
CSA=0
Suppress formatting of the CSA.
CSA=2
Format the CSA and its extension, the optional features list
(CSAOPFL).
DB2 [={0|1|2|3}]
The CICS DB2 interface.
Note: IPCS does not produce page numbers if formatting directly to the
terminal.
JCP [={0|2}]
The journal control area.
You can also specify the options for TS with angled brackets, for:
TS=<1>
Summary
TS=<2>
Format control blocks
TS=<3>
Consistency checking of the TS buffers with the TS control blocks
You can specify more than one of these values between angled brackets. For
example, TS=<1,2> gives summary and formatting of control blocks without
consistency checking.
UEH[={0|2}]
The user exit handler.
UEH=0
Suppress formatting of control blocks.
UEH=2
Format control blocks.
US[={0|1|2|3}]
The user domain.
US=0 Suppress formatting of user domain control blocks.
US=1 Format the user domain summary.
US=2 Format the control blocks.
US=3 Format level-1 and level-2 data.
WB[={0|1|2}]
The web interface.
WB=0 Suppress formatting of web interface control blocks.
WB=1 Format the web interface summary. This displays the current state of
the CICS web interface, followed by a summary of the state blocks
controlled by the state manager.
WB=2 Format the control blocks. This displays the current state of the CICS
web interface, followed by the web anchor block, the global work area
and associated control blocks, and the web state manager control
blocks.
XM[={0|1|2|3}]
The transaction manager.
XM=0 Suppress formatting of transaction manager control blocks.
XM=1 Format the domain summary, global state summary, transaction
summary, transaction class summary, and MXT summary.
XM=2 Format the control blocks including the transaction domain anchor
block, transactions (TXn), and transaction class control blocks (TCL).
XM=3 Format level-1 and level-2 data.
For a more detailed list of the contents of SDUMPs for each of the VERBEXIT
keywords, see “Appendix A. SDUMP contents and IPCS CICS VERBEXIT
keywords” on page 315.
Exceptions to the scope of the DEF parameter: There are two parts of a CICS
system dump that are not governed by component keywords, and are therefore
outside the scope of the DEF parameter. These are:
1. The dump summary
2. The error message index.
These parts of a CICS system dump are always formatted, even if you specify
DEF=0 and no component keywords.
The storage freeze function is invoked by the CSFE transaction. For information
about using CSFE, see the CICS Supplied Transactions manual.
In response to the DUMP command, the system prompts you with a reply number
for the dump options you want to specify. When prompted for dump parameters in
response to the DUMP COMM command, enter the reply:
REPLY nn,STRLIST=(STRNAME=DFHCFLS_poolname,ACCESSTIME=NOLIMIT,
(LISTNUM=ALL,ADJUNCT=DIRECTIO,ENTRYDATA=UNSERIALIZE)),END
Using abbreviations for the keywords, this reply can be entered as:
R nn,STL=(STRNAME=DFHCFLS_poolname,ACC=NOLIM,
(LNUM=ALL,ADJ=DIO,EDATA=UNSER)),END
For more information about the MVS DUMP command, see OS/390 MVS System
Commands, GC28-1781 .
The key of each entry in this list is the table name, and the first word of the adjunct
area is the corresponding data list number. If the table is open, entry data is present
containing a list of information about the current table users (regions that have the
table open). Each one is identified by its MVS system name and CICS APPLID. The
You can display the table data by converting the data list number to decimal and
specifying it on another STRDATA subcommand. For example, if the first word of
the adjunct area is X'00000027', the command to display the table data is as
follows:
STRDATA DETAIL LISTNUM(39) ENTRYPOS(ALL)
In the data list, the key of each entry is the record key, and the data portion
contains the user data with a 2-byte length prefix (or a 1-byte X'80' prefix if the data
length is 32767 bytes). The rest of any data area is uninitialized and can contain
residual data up to the next 256-byte boundary. The entry version contains the time
stamp at the time the record was last modified or created.
The adjunct area contains information for locking and recovery. It contains null
values (binary zeros) if the record is not locked. When the record is locked, the lock
owner APPLID and UOWID appear in this area.
If a record has a recoverable rewrite pending, there are two entries with the same
key, where the second entry is the before-image.
For information about the STRDATA subcommand and its options, see OS/390 MVS
IPCS Commands, GC28-1754 .
In response to the DUMP command, the system prompts you with a reply number
for the dump options you want to specify. When prompted for dump parameters in
response to the DUMP COMM command, enter the reply:
REPLY nn,STRLIST=(STRNAME=DFHNCLS_poolname,ACCESSTIME=NOLIMIT,
(LISTNUM=ALL,ADJUNCT=DIRECTIO)),END
Using abbreviations for the keywords, this reply can be entered as:
R nn,STL=(STRNAME=DFHNCLS_poolname,ACC=NOLIM,(LNUM=ALL,ADJ=DIO)),END
For more information about the MVS DUMP command, see OS/390 MVS System
Commands, GC28-1781 .
The key of each entry in this list is the counter name. The version field contains the
counter value minus its maximum value minus 3 (in twos complement form) which
has the effect that all counters have a value of -2 when they have reached their
limit (and the value of -1, equal to all high values, never occurs). The start of the
adjunct area contains the 8-byte minimum and maximum limit values that apply to
the counter.
For information about the STRDATA subcommand and its options, see OS/390 MVS
IPCS Commands, GC28-1754 .
Typically, the global trap/trace exit is used to detect errors that cannot be diagnosed
by other methods. These might cause intermittent problems that are difficult to
reproduce, the error perhaps occurring some time before the effects are noticed.
For example, a field might be changed to a bad value, or some structure in storage
might be overlaid at a specific offset.
The code in DFHTRAP must not make use of any CICS services, cause the current
task to lose control, or change the status of the CICS system.
When CICS is running, activation and deactivation of the trap exit routine can be
requested using the TRAP operand of the CSFE DEBUG command:
CSFE DEBUG,TRAP={ON|OFF}
The trap exit can also be activated at CICS initialization by specifying TRAP=ON,
either in DFHSIT or as a startup override. If you want to replace a trap exit routine
while CICS is running, use the CSFE DEBUG commands in conjunction with the
CEMT NEWCOPY command. The following sequence of commands causes the
currently active version of DFHTRAP to be refreshed:
CSFE DEBUG,TRAP=OFF
CEMT SET PROGRAM(DFHTRAP) NEWCOPY
CSFE DEBUG,TRAP=ON
The DSECT also contains EQU statements for use in setting the return-action flag
byte.
The exit can look at data from the current trace entry to determine whether or not
the problem under investigation has appeared. It can also look at the TCA of the
current task, and the CSA. The DSECTs for these areas are included in the
skeleton source.
The CSA address is zero for invocations of DFHTRAP early in initialization, before
the CSA is acquired.
Any combination of these actions can be chosen and all actions are honored on
return to the trace domain.
To reactivate the trap exit when it has been disabled, use CSFE
DEBUG,TRAP=ON, unless the exit routine is to be replaced. In this case the
sequence of commands given above applies.
The skeleton program shows how to make a further trace entry. When DFHTRAP
detects a TS GET request, it asks for a further trace entry to be made by entering
the data required in the area supplied for this purpose, and by setting the
appropriate bit in the return-action flag byte.
The trace domain then makes a trace entry with trace point ID TR 0103,
incorporating the information supplied by the exit.
Trace entries created in this way are written to any currently active trace
destination. This could be the internal trace table, the auxiliary trace data set, or the
GTF trace data set.
The skeleton DFHTRAP also shows how to detect the trace entry made by the
storage manager (SM) domain for a GETMAIN request for a particular subpool.
This is provided as an example of how to look at the data fields within the entry.
To recover from this situation, execute the commands given above for replacing the
current version of the exit routine.
Part 4 contains:
This section helps you decide when to contact the Support Center, and what
information you need to collect before contacting the Center. The section also gives
you an understanding of the way in which IBM Program Support works.
In practice, many errors reported to Program Support turn out to be user errors, or
they cannot be reproduced, or they need to be dealt with by other parts of IBM
Service. This indicates just how difficult it can be to determine the precise cause of
a problem. User errors are mainly caused by faults in application programs and
errors in setting up systems. TCT parameters, in particular, have been found to
cause difficulty in this respect.
The Support Center needs to know as much as possible about your problem, and
you should have the information ready before making your first call. It is a good
idea to put the information down on a problem reporting sheet, such as the one
shown in Figure 57 on page 304.
Make a note of the incident number on your own problem reporting sheet. The
Center expects you to quote the incident number in all future calls connected with
this problem.
If the problem is new to you, the operator asks you for the source of the problem
within your system software—that is, the program that seems to be the cause of the
problem. As you are reading this book, it is likely that you have already identified
CICS as the problem source. You also need to give the version and release
number, for example Version 4 Release 1.
You need to give a severity level for the problem. Severity levels can be 1, 2, or 3.
They have the following meanings:
v Severity level 1 indicates that you are unable to use a program, resulting in a
critical condition that needs immediate attention.
v Severity level 2 indicates that you are able to use the program, but that operation
is severely restricted.
v Severity level 3 indicates that you are able to use the program, with limited
functions, but the problem is not critical to your overall operation.
When deciding the severity of the problem, take care neither to understate it nor to
overstate it. The Support Center procedures depend on the severity level so that
the most appropriate use can be made of the Center’s skills and resources. Your
problem is normally dealt with immediately if it is severity level 1.
Finally, the call receipt operator offers you a selection of specific component areas
within CICS (for example, terminal control, file control) and asks you to choose the
area where your problem appears to lie. Based on this selection, the operator can
route your call to a specialist in the chosen area.
You are not asked for any more information at this stage. However, you need to
keep all the information relevant to the problem, and any available documentation
such as dumps, traces, and translator, compiler, and program output.
Let the representative know if any of the following events occurred before the
problem appeared:
v Changes in level of MVS or licensed programs
v Regeneration of any product
v PTFs applied
v Additional features used
v Application programs changed
v Unusual operator action.
You might be asked to give values from a formatted dump or trace table. You might
also be asked to carry out some special activity, for example to set a trap, or to use
trace with a certain type of selectivity, and then to report on the results.
The result of the investigations determines whether your problem is a new one, or
one that is already known. If it is already known, and a fix has been developed, the
fix is sent to you.
If the problem is new, an APAR may be submitted. This is dealt with by the CICS
change team. See “Chapter 19. APARs, fixes, and PTFs” on page 309.
When the change team solves the problem, they produce a fix enabling you to get
your system running properly again. Finally, a PTF is produced to replace the
module in error, and the APAR is closed.
When the APAR is entered, you are given an APAR number. You must write this
number on all the documentation you submit to the change team. This number is
always associated with the APAR and its resolution and, if a code change is
required, it is associated with the fix as well.
The next stage in the APAR process, getting relevant documentation to the change
team, is up to you.
Make sure the problem you have described can be seen in the documentation you
send. If the problem has ambiguous symptoms, you need to reveal the sequence of
events leading up to the failure. Tracing is valuable in this respect, but you might be
able to provide details that trace cannot give. You are encouraged to annotate your
documentation, if your annotation is legible and if it does not cover up vital
information. You can highlight data in any hard copy you send, using transparent
highlighting markers. You can also write notes in the margins, preferably using a red
pen so that the notes are not overlooked.
If you include any magnetic tapes, write this clearly on the outside of the box. This
lessens the chance of their being stored in magnetic fields strong enough to
damage the data.
You also need a mailing label with the address of the CICS change team on it.
When the change team receives the package, this is noted in your APAR record on
the RETAIN system. The team then investigates the problem. Occasionally, they
need to ask the Support Center to contact you for more documentation, perhaps
specifying some trap you must apply before getting it.
When the problem is solved, a code is entered on RETAIN to close the APAR, and
you are provided with a fix.
You can enquire any time at your Support Center on how your APAR is progressing,
particularly if it is a problem of high severity.
When the team is confident that the fix is satisfactory, the APAR is certified by the
CICS development team and the APAR is closed. You receive notification when this
happens.
If you cannot assemble the module yourself, because it involves a part of CICS that
is object serviced, you might be supplied with a ZAP or a TOTEST PTF.
If you want a PTF to resolve a specific problem, you can order it explicitly by its
PTF number through the IBM Support Center. Otherwise, you can wait for the PTF
to be sent out on the standard distribution tape.
The first table provides a list of IPCS CICS VERBEXIT keywords and the CICS
control blocks that they display.
The second table provides a list of all CICS control blocks in an SDUMP,
alphabetically, with their associated IPCS CICS VERBEXIT keyword.
PG keyword
The summaries appear below in the sequence in which they appear in a dump.
This is broadly the sequence in which the control blocks are listed in “Appendix A.
SDUMP contents and IPCS CICS VERBEXIT keywords” on page 315
form=numonly, but note:
v The system LLE summary, if present, follows the PGA summary, but the task LLE
summary, if present, follows the PTA summary.
v The HTB does not appear in a summary.
PGWE Summary
PGWE-ADD
Address of suspended program.
PROGRAM
Name of suspended program.
SUS-TOKN
Suspend token.
PPTE-ADD
Program PPTE address.
PPTE Summary
PPTE ADDRESS
Address of PPTE block.
PROGRAM NAME
The tables are indexed using the program name.
MOD TYPE
Module type, one of the following:
v PG - Program
v MP - Mapset
v PT - Partitionset.
LANG DEF
Language defined, one of the following:
v NDF - Not defined
PTA Summary
TRAN NUM
Transaction number.
PTA ADDRESS
Address of PTA.
LOG-LVL
Logical level count in decimal.
SYS-LVL
System level count in decimal.
TASK-LLE
Address of task LLE head, zero if no task LLE exists.
PLCB Address of PLCB head, or zero if no PLCB exists.
US keyword
A level-1 dump summarizes only the user domain data (USUD). The fields
displayed are the same for each type of USUD (principal, session, or EDF).
USXD summary
TRAN NUM
Transaction number.
PRINCIPAL TOKEN
Principal token, if any.
SESSION TOKEN
Session token, if any.
EDF TOKEN
EDF token, if any.
USUD summary
TOKEN
User token.
USERID
User identifier.
GROUPID
Group identifier.
ADDCOUNT
Adduser use count.
TRNCOUNT
Transaction use count.
OPID Operator identifier.
CLASSES
A bitmap expressing the operator classes in order 24 to 1.
PRTY Operator priority.
The above titles are the only unlicensed books available in hardcopy for CICS
Transaction Server for z/OS Version 2 Release 1. All the remaining CICS and
CICSPlex SM books are supplied in softcopy only in the CICS Information Center,
which is distributed on CD-ROM.
Note: The CICS Transaction Server for OS/390: Planning for Installation book that
was part of the library for CICS Transaction Server for OS/390, Version 1
Release 3, is now merged with the CICS Transaction Server for z/OS
Installation Guide. If you have any questions about the CICS Transaction
Server for z/OS library, see CICS Transaction Server for z/OS Installation
Guide which discusses both hardcopy and softcopy books and the ways that
the books can be ordered.
For CICS Transaction Server books, these softcopy updates appear regularly on the
Transaction Processing and Data Collection Kit CD-ROM, SK2T-0730-xx. Each
reissue of the collection kit is indicated by an updated order number suffix (the -xx
part). For example, collection kit SK2T-0730-06 is more up-to-date than
SK2T-0730-05. The collection kit is also clearly dated on the cover.
Updates to the softcopy are clearly marked by revision codes (usually a “#”
character) to the left of the changes.
Bibliography 341
342 CICS Transaction Server: CICS Problem Determination Guide
Index
A ALTSCREEN attribute, 178, 182
Any_MBCB resource type 74
abbreviated-format trace 250
Any_MRCB resource type 74
abend codes
AP_INIT resource type 74
transaction 29
AP_QUIES resource type 74
AICA 30
AP_TERM resource type 74
ASRA 30
APAR (authorized program analysis report)
ASRB 31
authorization 309
CICS 30
closing 311
destination 29
documentation needed 309
documentation 30
process 309
interpretation 30
submitting 310
product other than CICS 30
APPC (LUTYPE6.2), range of devices 102
user 30
application programs
ABEND symptom keyword 7
dynamic storage 279
abends
storage areas 279
AICA 150
arithmetic exceptions 34
DBCTL interface 39
investigating 34
dump not made when expected 173
ASIS option 178
exception trace entry 44
ASRA abend
investigating 43
causes 30
the documentation you need 43
execution key 275
looking at the symptom string 45
PSW 275
symptom keyword 7
registers 275
transaction 29
ASRB abend
AICA 30
causes 31
ASRA 30
execution key 275
ASRB 31
PSW 275
worksheet 39
registers 275
access method
ASRD abend
determining the type in use 103
causes 31
intersystem communication 104
PSW 275
ISMM 104
registers 275
possible reason for stalled system 146
assembler programs
TCAM 104
locating the DFHEISTG storage 279
VTAM
assemblers
terminal control waits 109
errors in output 6
terminal waits 104
asynchronous processing 108
ADD_SUSPEND function 64
ASYNRESP resource name 74
input parameters 64
ATCHMSUB, resource name 76
output parameters 65
ATI (automatic transaction initiation) 106
addressing exception 34
autoinitiated tasks
AEYD
excessive numbers shown in statistics 14
causes 31
automatic initiate descriptor (AID)
AICA abend
identifying the related task 189
probable cause 30
identifying the terminal 189
PSW 275
investigating tasks that have not started 188
registers 275
automatic transaction initiation (ATI)
AICA abends 150
task produced no output 185, 188
AID chain
looking at the AID chain 188
investigating tasks that have not started 188
looking at the ICE chain 188
locating in the formatted system dump 189
resource not available 188
AIDTRMID (symbolic ID of terminal) 189
task not yet scheduled to start 188
AIDTRNID (transaction ID) 189
automatic transaction initiation session status 106
AITM resource name 75
auxiliary trace 251
ALLOCATE resource type 74, 111
abbreviated-format 250
alternate system waits 140
advantages 242
ALTPAGE attribute 178, 182
characteristics 241
Index 345
CSFE DEBUG transaction (continued) deadlocks
TRAP operand 297 resolving 130
CSFE transaction resolving in a sysplex 134
checking the programming logic 192 debugging
storage freeze option 192 IRC problems 205
CSFE ZCQTRACE transaction multiregion operation problems 205
dumps of builder parameter set 272 DEF parameter of CICS610 dump exit 282
CSMT log DELETE_SUSPEND function of gate DSSR 65
abend messages 3, 9, 10 input parameters 65
terminal error messages 10, 102 output parameters 66
CSNC resource type 75 destination control table (DCT)
CURRENTDDS, transaction dump data set status 273 extrapartition transient data destination 112
CWA (common work area) 276 logically recoverable queues 113
DFHAIIN resource type 75
DFHAUXT 241
D DFHBUXT 241
data corruption DFHCPIN resource type 75
bad programming logic 191 DFHDMPA dump data set 273
incorrect mapping to program 191 DFHDMPB dump data set 273
incorrect mapping to terminal 192 DFHDU610 job log 274
attributes of fields 192 DFHEIB 276
DARK field attribute 192 EIBFN 276
MDT 192 DFHEISTG 279
modified data tag 192 DFHKC TYPE=DEQ macro 97
symbolic map 192 DFHKC TYPE=ENQ macro 95
incorrect records in file 190 DFHKC TYPE=WAIT macro 95
missing records in file 190 DCI=CICS option 96
possible causes 190 DCI=LIST option 96
data exception 33 DCI=SINGLE option 96
DATABUFFERS parameter of FILE resource DCI=TERMINAL option 96
definition 121 DFHPRIN resource type 76
DB2_INIT resource type 75 DFHSIPLT resource name 79
DB2 migration considerations DFHSIPLT resource type 76
DSNTIAR 37 DFHSTATE_TOKEN resource type 76
DB2 resource type 75 DFHTACB 277, 278
DB2CDISC resource type 75 PSW 277
DB2EDISA resource type 75 registers 277
DB2START, resource name 82 DFHTEMP resource name 82
DBCTL (database control) DFHTRADS DSECT 297
abends 39 DFHZARER resource name 84
connection fails 93 DFHZARL1 resource name 83
disconnection fails 94 DFHZARL2 resource name 84
immediate disconnection 94 DFHZARL3 resource name 84
orderly disconnection 94 DFHZARL4 resource name 83
waits 93 DFHZARQ1 resource name 83
DBCTL resource type 75, 93 DFHZARR1 resource name 83
DBDXEOT resource type 75 DFHZCRQ1 resource name 83
DBDXINT resource type 75 DFHZDSP resource name 81
DBUGUSER resource name 76 DFHZEMW1 resource name 83
DCT resource name 81 DFHZERH1 resource name 84
DEADLOCK_ACTION DFHZERH2 resource name 84
description of parameter 70 DFHZERH3 resource name 84
SUSPEND input parameter 66 DFHZERH4 resource name 84
WAIT_MVS input parameter 69 DFHZIS11 resource name 83
WAIT_OLDC input parameter 69 DFHZRAQ1 resource name 83
WAIT_OLDW input parameter 69 DFHZRAR1 resource name 83
deadlock time-out interval diagnostic run, of CICS 216
description 70 DISASTER value of dispatcher RESPONSE output
EXEC CICS WRITEQ TS command 99 parameter 71
interval control waits 135 DISOSS, communication with CICS 102
task storage waits 97 DISPATCH resource type 76
Index 347
dumps (continued) ENQUEUE resource type 76, 77, 95, 97, 122
dump output is incorrect (continued) BDAM record locking 129
some dump IDs missing from the sequence of ESDS write lock 130
dumps 175 KSDS range lock 130
wrong CICS region 173 VSAM load mode lock 130
dumps 18 VSAM record locking 129
events that can cause dumps 256 enqueue waits 115
formatting a CFDT pool dump 293 ERDSA resource type 77
formatting a named counter pool dump 295 error code 48
formatting keywords 282 error data 49
formatting levels 282 error number 48
IDs missing from the sequence of dumps 175 error type 48
in a sysplex 258 ESDSA resource type 77
in problem determination 255 EUDSA resource type 77
looking at the symptom string 45 event monitoring point (EMP) 19
named counter list structure dump 294 exceeding the capacity of a log stream 208
options 266 exception trace
requesting dumps 256 characteristics 227
setting the dumping environment 255 CICS system abends 44
suppressing 174, 256 destination 227
DUMPSCOPE dump code option 257, 258 format 227
DUMPSW, system initialization parameter 273 missing trace entries 173
DURETRY, system initialization parameter 273 purpose 227
storage violation 195, 196, 199
user 228
E EXCEPTION value of dispatcher RESPONSE output
EARLYPLT resource name 76 parameter 71
ECB (event control block) EXCLOGER resource name 74
EXEC CICS POST command 136 exclusive control of volume conflict 146
finding the address. 96 EXEC CICS ABEND command 257
function WAIT_MVS of gate DSSR 68, 69 EXEC CICS DELAY command 135
function WAIT_OLDC of gate DSSR 68, 69 EXEC CICS DUMP TRANSACTION command 256,
function WAIT_OLDW of gate DSSR 68, 69 272
invalid address, task control waits 96 EXEC CICS ENTER TRACENUM command 228
posting after task is canceled 199 EXEC CICS INQUIRE TASK
PSTDECB 92 SUSPENDTYPE field 57
storage violations 199 SUSPENDVALUE field 57
valid address, task control waits 97 EXEC CICS PERFORM DUMP command 256
ECB_ADDRESS EXEC CICS POST 136
WAIT_MVS input parameter 69 EXEC CICS READ UPDATE command 127
WAIT_OLDC input parameter 69 EXEC CICS RETRIEVE WAIT command 135
WAIT_OLDW input parameter 69 EXEC CICS REWRITE command 127
ECB_LIST_ADDRESS EXEC CICS START command 135, 161
WAIT_MVS input parameter 69 EXEC CICS STARTBR command 127
WAIT_OLDW input parameter 69 EXEC CICS WAIT EVENT command 136
ECBTCP resource name 74 EXEC CICS WRITE command 127
ECDSA resource type 76 EXEC CICS WRITE MASSINSERT command 127
EDF (execution diagnostic facility) EXEC CICS WRITEQ TS command 99
investigating loops 158 NOSUSPEND 99
use in investigating no task output 186 REWRITE option 99
waits 94 EXEC interface block (EIB)
EDF resource type 76 EIBFN 276
EDSA (extended dynamic storage area) EXECADDR resource name 76
current free space 98 EXECSTRN resource name 76
storage fragmentation 99 execution diagnostic facility (EDF)
EIBFN 276 investigating loops 158
in last command identification 278 execution exception 33
EKCWAIT resource type 76 Execution key 275
EMP (event monitoring point) 19 exit programming interface (XPI)
ENF resource type 76 ADD_SUSPEND function 64
ENQUEUE on single server resource 97 correctness of input parameters 4
Index 349
ICMIDNTE resource type 79 incorrect output (continued)
ICV, system initialization parameter symptoms 11
possible cause of CICS stall 145 temporary storage 20
ICVR, system initialization parameter terminal data 20
non-yielding loops 150 terminal output wrong 176
possible cause of CICS stall 145 trace 21
tight loops 150 trace data wrong 170
ICVTSD, system initialization parameter trace destination wrong 169
possible cause of CICS stall 146 trace entries missing 171
ICWAIT resource type 79, 101, 135 trace output wrong 169
IIOP transaction inputs and outputs 19
waits 111 transient data 20
incorrect output unexpected messages 11
abend codes 18 user documentation 17
application did not work as expected 183 wrong CICS components being traced 171
BMS mapping 192 wrong output obtained 190
attributes of fields 192 possible causes 190
DARK field attribute 192 wrong tasks being traced 171
MDT 192 INCORROUT symptom keyword 7
modified data tag 192 INDEXBUFFERS parameter of FILE resource
symbolic map 192 definition 121
change log 18 INFORMATION/ACCESS licensed program 7
checking for bad data in a file 190 information sources 17
checking the mapping from file to program 191 INITIAL resource name 74
checking the programming logic 191 initialization stall 144
desk checking 191 INQUIRE_ resource name 83
using CEBR 191 INQUIRE_SUSPEND_TOKEN function of gate
using CECI 191 DSSR 65
using CEDF 191 output parameters 65
using interactive tools 191 INQUIRE UOWENQ command
databases 21 deadlock diagnosis 134
error messages 18 interactive problem control system (IPCS)
files 21 analyzing CICS system dumps 280
incorrect output read from VSAM data set 183 CICS system abends 44
investigating 169 CICS610 dump exit 282
link-edit maps 17 internal trace 251
manuals 17 abbreviated-format 250
monitoring 19 characteristics 241
no output obtained 184 controlling 243
ATI tasks 185, 188 destination 241
disabling the transaction 188 exception trace destination 241
explanatory messages 184 extended-format 246
finding if the task ran 185 formatting 246
looking at files 188 interpreting 246, 250
looking at temporary storage queues 187 short-format 251
looking at transient data queues 187 status 241, 243
possible causes 184 trace entries missing 172
START PRINTER bit on write control trace table size 241
character 185 changing the size dynamically 241
task not in system 185 wrapping 241
task still in system 185 intersystem communication (ISC)
testing the terminal status 184 poor performance 161
using CECI 188 waits 108, 111
using execution diagnostic facility 186 INTERVAL
using statistics 186, 187 description of parameter 70
using trace 185 SUSPEND input parameter 66
passed information 20 WAIT_MVS input parameter 69
printed output wrong 176 WAIT_OLDC input parameter 69
source listings 17 WAIT_OLDW input parameter 69
statistics 19 interval control
symptom keyword 7 element 136
Index 351
loops (continued) MONITOR POINT command 19
symptom keyword 7 monitoring point 19
symptoms 12, 13, 149 MRCB_xxx resource type 80
CICS region stalled 13 MRO waits 108, 111
CPU usage high 13 MROQUEUE resource name 75
reduced activity at terminals 13 MSBRETRN, resource name 76
repetitive output 13 multiregion operation using IRC 205
short on storage 14 multiregion operation waits 108, 111
system busy symbol 13 MVS ABEND macro 31
tight 149 MVS console
characteristics 150 CICS termination message 8
finding the cause 156 MVS RESERVE locking
identifying an instruction in the loop 155 CEDA in a wait state 142
investigating 154 CESN in a wait state 142
possible causes 156 CICS system stalls 146
types 149 effect on CICS performance 166
using CEBR 158 transient data extrapartition waits 112
using CECI 158 VSAM I/O waits 123
using CEDF 158 waits during XRF takeover 142
using the CEMT transaction 14 waits on resource type XRPUTMSG 142
using trace 154, 156 MXT (maximum tasks value)
yielding 149 effect on performance 162
characteristics 152 kernel task summary 47
finding the cause 157 possible cause of CICS stall 146
investigating 156 reason for task failing to start 10
possible causes 157 waits 85
useful documentation 157 XM_HELD resource type 85
LOT_ECB resource name 75 MXT resource type 80
lowercase characters 178
LUTYPE6.1, range of devices 102
N
NetView 147
M networks
MBCB_xxx resource type 80 messages 102
MESSAGE symptom keyword 7 preliminary checks 5
messages NOSYSDUMP, system dump code attribute 175
absence of, when expected 13 NOTRANDUMP, transaction dump code attribute 175
CICS under stress 14
destination
CDBC 10 O
CSMT 9, 10 OK value of dispatcher RESPONSE output
CSTL 10 parameter 71
DFHAC2008 188 ONC/RPC 7
DFHSM0131 15, 164 OPEN_DEL wait 85
DFHSM0133 15, 164 OPEN_TCB resource name 76
DFHSR0601 9 OPEN_TCB wait 85
DFHST0001 9 open transaction environment
dump formatting error 196 TCB stealing 85
preliminary checks 3 operation exceptions 33
short on storage 164 OTHER_PRODUCT value of WLM_WAIT_TYPE input
sources 4 parameter 71
storage violation 193, 196 output
symptom keyword 7 absence when it is expected 12
terminal errors 102 none obtained 184
transaction abend 29 ATI tasks 185, 188
transaction disabled 188 disabling the transaction 188
unexpected 11, 178 explanatory messages 184
MISC value of WLM_WAIT_TYPE input parameter 71 finding if the task ran 185
missing trace entries 171 looking at files 188
module index looking at temporary storage queues 187
in transaction dump 277 looking at transient data queues 187
Index 353
program check (continued)
specification exception 34
Q
QSAM 112, 166
system interrupts 34
QUIESCE resource name 76
wild branch 32
quiesce stall 147
program check and abend tracing 230
program control waits 115
program interrupt code (PIC)
addressing exception 34 R
arithmetic exceptions 34 RCP_INIT resource type 80
data exception 33 RDSA resource type 80
execution exception 33 REASON
interpretation 32 ADD_SUSPEND output parameter 65
operation exception 33 DELETE_SUSPEND output parameter 66
privileged operation 33 RESUME output parameter 68
protection exception 33 SUSPEND output parameter 67
specification exception 34 WAIT_MVS output parameter 70
system interrupts 34 WAIT_OLDC output parameter 70
program list table (PLT) WAIT_OLDW output parameter 70
programs executing during CICS quiesce 147 record locking
transient data waits 112, 144 BDAM data sets 129
PROGRAM resource type 80 VSAM data sets 129
program status word (PSW) 30 registers
programming errors at time of error 49
preliminary checks 6 CICS system abends 49
programs data addressed at the time of error 50
information for current transaction 277 in transaction abend control block 277
loops 149 in transaction dump 275
problems with loading 115 registers at last EXEC command 275
representation in linkage stack 51 RELATED dump code attribute 257, 258
storage 277 Remote abend indicator 275
protection exception 33 resource definition online (RDO)
dealing with 35 ALTER mapset 5
possible causes 36 ALTER program 5
PSB (program specification block) ALTER transaction 5
load I/O 92 DEFINE mapset 5
PSINQECB resource name 83 DEFINE program 5
PSOP1ECB resource name 83 DEFINE transaction 5
PSOP2ECB resource name 83 INSTALL option 5
PSTDECB 92 RESOURCE_NAME
PSUNBECB resource name 83 ADD_SUSPEND input parameter 64
PSW (program status word) SUSPEND input parameter 66
at time of error 49 WAIT_MVS input parameter 69
CICS system abends 49 WAIT_OLDC input parameter 69
description 30 WAIT_OLDW input parameter 69
finding the offset of a failing instruction 52 resource names
format 52 *CTLACB* 78
in transaction abend control block 277 AITM 75
in transaction dump 275 ASYNRESP 74
PTF 311 ATCHMSUB 76
PTF level 52 CDB2TIME 82
PURGEABLE operand CEX2TERM 76
SUSPEND input parameter 66 CHANGECB 83, 110
WAIT_MVS input parameter 69 CICS 79
WAIT_OLDC input parameter 69 CPI 75
WAIT_OLDW input parameter 69 CSASSI2 74
PURGED value of dispatcher RESPONSE output DB2START 82
parameter 71 DBUGUSER 76
DCT 81, 112
DFHSIPLT 79
DFHTEMP 82
DFHXMTA 78
Index 355
resource types (continued) resource types (continued)
DBDXEOT 75 LGSTRBLK 80, 95
DBDXINT 75 LGSTRCRS 80, 95
DFHAIIN 75 LGWRITE 80, 95
DFHCPIN 75 MBCB_xxx 80, 114
DFHPRIN 76 MRCB_xxx 80, 114
DFHSIPLT 76 MXT 80
DFHSTATE_TOKEN 76 PROGRAM 80
DISPATCH 76 RCP_INIT 80
DMATTACH 76 RDSA 80
DSTSKDEF 85 SDSA 81
ECDSA 76, 97 STP_TERM 81
EDF 76, 94 SUCNSOLE 81
EKCWAIT 76, 95 summary of possible values 73
ENF 76 SUSPENDTYPE 57
ENQUEUE 76, 77, 113 TCP_NORM 81
ERDSA 77, 97 TCP_SHUT 81
ESDSA 77 TCTVCECB 81
EUDSA 77, 97 TD_INIT 81, 112
FCACWAIT 77 TD_READ 81, 113
FCBFWAIT 77, 121 TDEPLOCK 81, 112
FCCAWAIT 77, 121 TDIPLOCK 81, 113
FCCFQR 77, 122 TIEXPIRY 81
FCCFQS 77, 122 TRANDEF 81
FCCRWAIT 77 TSAUX 82, 99
FCDWWAIT 77, 122 TSBUFFER 100
FCFSWAIT 78, 122 TSEXTEND 100
FCINWAIT 78 TSIO 101
FCIOWAIT 78, 123 TSIOWAIT 82
FCIRWAIT 78, 123 TSPOOL 82, 101
FCPSWAIT 78, 123 TSQUEUE 101
FCQUIES 78, 124 TSSHARED 82, 101
FCRAWAIT 78, 124 TSSTRING 101
FCRBWAIT 78, 124 TSWBUFFR 101
FCRDWAIT 78, 124 UDSA 82, 97
FCRPWAIT 78, 125 USERWAIT 82, 95
FCRRWAIT 78, 125 XRGETMSG 82
FCRVWAIT 78, 125 XRPUTMSG 142
FCSRSUSP 78, 123 ZC 83, 109
FCTISUSP 78, 126 ZC_ZCGRP 83, 110
FCXCWAIT 78, 126 ZC_ZGCH 83, 110
FOREVER 78 ZC_ZGIN 83, 110
HTYPE 57 ZC_ZGRP 83, 110
ICEXPIRY 78 ZC_ZGUB 83, 110
ICGTWAIT 79, 135 ZCIOWAIT 84, 110
ICMIDNTE 79 ZCZGET 84, 110
ICWAIT 79, 135 ZCZNAC 84, 111
inquiring during task waits 57 ZXQOWAIT 84, 111
IRLINK 79, 101, 108 ZXSTWAIT 84
KC_ENQ 95, 97, 122 resources
KCCOMPAT 79, 95, 96, 101 DBCTL 93
LATE_PLT 79 definition errors 5
LG_DEFER 79, 94 inquiring during task waits 57
LG_FORCE 80, 94 locks 90
LGDELALL 79, 94 investigating waits 90
LGDELRAN 79, 95 log manager 94
LGENDBLK 79, 95 names 73
LGENDCRS 80, 95 storage manager 97
LGHARTBT 80 task control 95
LGREDBLK 80, 95 temporary storage 99
LGREDCRS 80, 95 types 73
Index 357
SUSPEND_TOKEN system task waits 73, 142
ADD_SUSPEND output parameter 65 intentional 142
DELETE_SUSPEND input parameter 65 SYSTR, system initialization parameter 237
INQUIRE_SUSPEND_TOKEN output parameter 65
RESUME input parameter 68
SUSPEND input parameter 66 T
SUSPENDTYPE field 57 task control
SUSPENDVALUE field 57 waits 95
symbolic maps 192 causes 96
symptom strings failure of task to DEQUEUE on resource 97
in transaction dump 274 invalid ECB address 96
problem determination 45 resource type KCCOMPAT 96
RETAIN database search 274 unconditional ENQUEUE on single server
RETAIN search keywords 45 resource 97
symptoms valid ECB address 97
CICS has stopped running 8 task control area (TCA)
CICS running slowly 9 in transaction dump 275
incorrect output 11 system area 275
keywords 7, 305 user area 275
loops 12, 13 task global table (TGT) 279
low priority tasks will not start 9 task termination
no output is obtained 9 abnormal 3
poor performance 9, 12, 14, 159 task tracing
tasks do not complete 9 precautions when choosing options 171
tasks in a wait state 12 special 235
tasks take a long time to complete 9 standard 235
tasks take a long time to start 9 suppressed 235
terminal activity is reduced 9 tasks
use in classifying problems 8 abnormal termination 3
waits 12 ATI, no output produced 185, 188
SYS1.DUMP data set 273 looking at the AID chain 188
SYSDUMP, system dump code attribute 175 looking at the ICE chain 188
SYSIDNT/session ID resource name 79 conversation state with terminal 107
sysplex dispatch, suspend and resume cycle 161, 165
MVS console commands 260 dispatching priority 164
problem determination 258 error data 49
resolving deadlocks 134 exclusive control deadlock 127
system busy symbol 13 failure during MVS service call 49
SYSTEM_DUMP, exit programming interface call 257 failure to complete 9, 10, 12
system initialization failure to get attached to the dispatcher 160, 162
AUXTR parameter 243 failure to get attached to the transaction
AUXTRSW parameter 243 manager 160, 161
defining component tracing requirements 239 failure to get initial dispatch 161, 164
defining the tracing status 243 failure to start 9, 10, 12
DUMP parameter 174, 255 failure under the CICS RB 49
DUMPDS parameter 273 identifying, in remote region 108
DUMPSW parameter 273 identifying the AID 189
DURETRY parameter 273 identifying the ICE 188
global suppression of CICS system dumps 255 in a wait state 12
GTFTR parameter 243 in error 46
INTTR parameter 243 identified in linkage stack 51
setting transaction dump data set attributes 273 information in kernel domain storage areas 47
SPCTR parameter 239 lock owning
SPCTRxx parameter 239 identifying a lock being waited on 90
STNTR parameter 239 looping 149
STNTRxx parameter 239 consumption of storage 98, 100
suppressing standard tracing 237 identifying the limits 157
SYSTR parameter 237 MXT limit 162
TRTABSZ parameter 243 PSW at time of error 49
USERTR parameter 243 reason for remaining on the AID chain 189
system loading, effect on performance 166 registers at time of error 49
Index 359
terminals (continued) trace (continued)
incorrect output displayed (continued) entries missing 171
some data not displayed 182 example of formatted entry 248, 249
unexpected messages and codes 178 extended-format 246, 276
unexpected uppercase or lowercase formatted entry
characters 178 data fields 247
wrong data values displayed 181 interpretation string 247
no input accepted 10 interval 247
no output 9, 10 kernel task number 247
range of characteristics 102 standard information string 247
reduced activity 9, 12, 13 task number 247
repetitive output 13 time of entry 247
status 105 trace point id 246
effect on performance 161 formatting 245
terminal control program 105 from global trap/trace exit 298
unresponsive 102 global trap/trace exit 297
termination in problem determination
abnormal 3 loops 154, 156
system dump code option 266 poor performance 163
transaction dump code option 266 selecting destinations 240
termination stall 147 storage violations 197, 200
TIEXPIRY resource type 81 incorrect output from
TIMER value of WLM_WAIT_TYPE input investigating 169
parameter 71 trace entries missing 171
trace wrong CICS components being traced 171
abbreviated format 276 wrong data captured 170
abbreviated-format 250 wrong destination 169
calls to other programs 226 wrong tasks being traced 171
CICS VTAM exit internal domain functions 226
advantages 231 interpreting 246, 250
controlling 231 user entries 252
description 230 interpreting user entries 252
destination 230 investigating waits 56, 57
destinations 169 setting the tracing options 57
identifying the terminal 231 last command identification 278
interpretation 231 last statement identification 278
terminal waits 108 level-1 226
CICS XRF trace level-2 226
description 228 level-3 226
destination 228 levels 226, 227
origin 228 logic of selectivity 237
controlling master system trace flag 170, 237, 244
auxiliary trace 243 master user trace flag 244
CICS GTF trace 243 MVS GTF 242
internal trace 243 common destination 242
special task tracing 235 overview of different types 225
special trace levels 238 point id 246
standard task tracing 235 points 225
standard trace levels 238 location 226
suppressing standard tracing 237 program check and abend 230
suppressing task tracing 235 repetitive output 13
data provided on call 226 storage manager trace levels 226
exception trace 227 suspension and resumption of tasks 57
destinations 169 interpreting the trace table 58
dfhtrap.invocation 297 use in investigating no task output 185
domain entry 226 user 191
domain exit 226 checking programming logic 191
DSSR functions 57 user exception trace entries 228
input and output parameters 58 VTAM buffer
interpreting the trace table 58 description 231
entries from AP domain 246, 248 destination 231
Index 361
transactions (continued)
wrong output produced (continued)
V
VARY NET,INACT command 147
possible causes 190
VSAM
transient data
data buffers 121
extrapartition destinations 112
exclusive control deadlock 127
performance considerations 166
exclusive control of control interval 126
I/O buffers 114
I/O waits 123, 125
intrapartition destinations 112
incorrect data read from file 183
no task output 187
index buffers 121
recoverable queues 112
strings 123
VSAM I/O 114
transaction ID waits 126
VSAM strings 114
waits
waits 111
exclusive control deadlock 127
during initialization 112
file state changes 122
extrapartition 112
for exclusive control of control interval 126
I/O buffer contention 114
for VSAM transaction ID 126
I/O buffers all in use 114
I/O 123
intrapartition 112
record locking by CICS 129
resource names 111
VSAM buffer unavailable 121
resource types 111
VSAM string unavailable 123
VSAM I/O 114
VSAM READ SEQUENTIAL 127
VSAM strings all in use 114
VSAM READ UPDATE 127
translator
VSAM WRITE DIRECT 127
errors in output 6
VSAM WRITE SEQUENTIAL 127
traps 297
VSMSTRNG resource name 74
TRTABSZ, system initialization parameter 243
VTAM
TSAUX resource type 82, 99
process status 104
TSBUFFER resource name 82, 100
session state with task 107
TSEXTEND resource name 82, 100
TSIO resource name 82, 101
TSIOWAIT resource type 82
TSNQ resource name 77 W
TSPOOL resource type 82, 101 WAIT_MVS function 68, 69
TSQUEUE resource name 82, 101 input parameters 69
TSSHARED resource type 82, 101 WAIT_OLDC function 68, 69
TSSTRING resource name 82, 101 input parameters 69
TSWBUFFR resource name 82, 101 WAIT_OLDW function 68, 69
TYPETERM definition input parameters 69
ALTPAGE attribute 178, 182 WAIT symptom keyword 7
ALTSCREEN attribute 178, 182 waits
ATI status 190 alternate system 140
CREATESESS(NO), cause of terminal waits 106 CICS DB2 92
EXTENDEDDS attribute 178, 182 DBCTL 93
PAGESIZE attribute 182 deadlock time-out interval 135
SENDSIZE attribute 182 definition 12, 55
UCTRAN attribute 178 EDF 94
enqueue 115
FEPI 143
U file control 118
IIOP 111
UCTRAN attribute 179
interregion communication 108, 111
PROFILE definition 178
intersystem communication 108, 111
TYPETERM definition 178
interval control 135
UDSA resource type 82
investigating 55
uppercase characters 178
lock manager 90
user task waits 73
log manager 94
user tracing
maximum task conditions 85
checking programming logic 191
online investigation 56
exception trace entries 228
finding the resource 57
interpretation 252
program control 115
USERTR, system initialization parameter 243
stages in resolving 55
USERWAIT resource type 82
X
XDUREQ, dump domain global user exit 174
XDUREQ global user exit 255
XLT (transaction list table) 147
XM_HELD resource type 85
XRF errors
failure of CAVM 142
XRF takeover
CEDA in a wait state 142
CESN in a wait state 142
wait on resource type XRPUTMSG 142
XRGETMSG resource type 82
XRPUTMSG resource type 82, 142
Z
ZC resource type 83
ZC_ZCGRP resource type 83
ZC_ZGCH resource type 83
ZC_ZGIN resource type 83
ZC_ZGRP resource name 81
ZC_ZGRP resource type 83
ZC_ZGUB resource type 83
ZCIOWAIT 84
ZCZGET resource type 84
ZCZNAC resource type 84
ZGRPECB resource name 74
ZSLSECB resource name 83
ZXQOWAIT resource type 84
ZXSTWAIT resource type 84
Index 363
364 CICS Transaction Server: CICS Problem Determination Guide
Notices
This information was developed for products and services offered in the U.S.A. IBM
may not offer the products, services, or features discussed in this document in other
countries. Consult your local IBM representative for information on the products and
services currently available in your area. Any reference to an IBM product, program,
or service is not intended to state or imply that only that IBM product, program, or
service may be used. Any functionally equivalent product, program, or service that
does not infringe any IBM intellectual property right may be used instead. However,
it is the user’s responsibility to evaluate and verify the operation of any non-IBM
product, program, or service.
IBM may have patents or pending patent applications covering subject matter
described in this document. The furnishing of this document does not give you any
license to these patents. You can send license inquiries, in writing, to:
For license inquiries regarding double-byte (DBCS) information, contact the IBM
Intellectual Property Department in your country or send inquiries, in writing, to:
The following paragraph does not apply in the United Kingdom or any other
country where such provisions are inconsistent with local law:
INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS
PUBLICATION “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A
PARTICULAR PURPOSE. Some states do not allow disclaimer of express or
implied warranties in certain transactions, therefore this statement may not apply to
you.
Licensees of this program who wish to have information about it for the purpose of
enabling: (i) the exchange of information between independently created programs
and other programs (including this one) and (ii) the mutual use of the information
which has been exchanged, should contact IBM United Kingdom Laboratories,
MP151, Hursley Park, Winchester, Hampshire, England, SO21 2JN. Such
information may be available, subject to appropriate terms and conditions, including
in some cases, payment of a fee.
Trademarks
The following terms are trademarks of International Business Machines Corporation
in the United States, or other countries, or both:
CICS NetView
CICS/ESA OS/390
CICS/MVS RETAIN
C/370 RMF
DB2 SP
IBM System/390
IMS VTAM
MVS/ESA
Other company, product, and service names may be trademarks or service marks
of others.
Feel free to comment on what you regard as specific errors or omissions, and on
the accuracy, organization, subject matter, or completeness of this book.
Please limit your comments to the information in this book and the way in which the
information is presented.
To ask questions, make comments about the functions of IBM products or systems,
or to request additional publications, contact your IBM representative or your IBM
authorized remarketer.
When you send comments to IBM, you grant IBM a nonexclusive right to use or
distribute your comments in any way it believes appropriate, without incurring any
obligation to you.
You can send your comments to IBM in any of the following ways:
v By mail, to this address:
User Technologies Department (MP095)
IBM United Kingdom Laboratories
Hursley Park
WINCHESTER
Hampshire
SO21 2JN
United Kingdom
v By fax:
– From outside the U.K., after your international access code use
44–1962–842327
– From within the U.K., use 01962–842327
v Electronically, use the appropriate network ID:
– IBM Mail Exchange: GBIBM2Q9 at IBMMAIL
™
– IBMLink : HURSLEY(IDRCF)
– Internet: idrcf@hursley.ibm.com
GC33-5719-00
Spine information:
Version 2
CICS Transaction Server CICS Problem Determination Guide Release 1