technical: Control Blocks for Beginners Pt 2: z/OS Control Blocks
In the first
part of this two part series, we introduced control blocks: what they are,
how to access them and how they can be useful. In this second article, we talk
about z/OS control blocks: the basic control blocks and how to write programs
to access them.
Introduction
In the previous article in this series, we introduced control blocks: what
they are, why they're used, and how to look at them. In this article, we're
going to look closer at z/OS control blocks. We'll look at some of the basic
control blocks that every Systems Programmer needs to know, and coding examples
to access these control blocks in Assembler, PL/1 and COBOL.
The Two Basic z/OS control blocks
If you're looking for control blocks in z/OS, the chances are that you'll start
looking for them by referring to the two basic z/OS control blocks that point
to almost everything: The PSA and CVT.
PSA - Prefixed Save Area
The PSA is the first control block you need. It holds the basic information
z/OS needs when scheduling work on a Central Processor (CP), which is why there's
one for every CP. And the PSA is easy to find - it's always at address zero.
The big things that PSA gives Systems Programmers are:
- FLCCVT - A pointer to the CVT (more on the CVT in a moment).
- PSAAOLD - A pointer to the Address Space Control Block (ASCB) of the address
space currently scheduled on this CP. The ASCB holds basic information about
an address space, including Jobname and Address Space ID. More information
is held in the Address Space Extension Block (ASXB), which is pointed to by
the ASCB.
- PSATOLD - A pointer to the Task Control Block (TCB) of the task currently
scheduled on this CP. The TCB holds information on a specific task.
CVT - Communication Vector Table
The CVT is a great control block. You can find pointers to a whole lot of other
control blocks from here, including all ASCBs, SSVTs (Subsystem Vector Table
- information on subsystems) and UCBs (Unit Control Blocks - information on
hardware units like DASD and tape). Think of the CVT as an index to all the
other z/OS control blocks.
So these basic control blocks are linked like this:
Accessing Control Blocks in Assembler
So now that we've been introduced to the basic z/OS control blocks, let's start
using them. Look at the Assembler (HLASM) example below:
* --- Get the CVT Address --------------------
L R1,FLCCVT-PSA(0) R1 -> CVT
* --- Get the SMCA Address -------------------
L R1,CVTSMCA-CVT(R1) R1 -> SMCA
* --- Get the z/OS SMFID --------------------
USING SMCABASE,R1
MVC ZOSNAME(L'SMCASID),SMCASID
* --- DSECTs we need for these control blocks --
IHAPSA , Map PSA
CVT DSECT=YES Map CVT
IEESMCA DSECT=YES Map SMCA
Figure 1: HLASM Code Fragment |
This fragment gets the name of the z/OS image - the SMFID. Looking at this
fragment, you can see that we
- get the address of the CVT from the PSA
- get the address of a control block called the SMCA (used to store SMF related
information)
- get the the SMFID from the SMCA.
You can also see that we include z/OS macros to include DSECTS that map these
control blocks at the bottom.
Control Blocks from High Level Languages
But you don't have to program in Assembler to access control blocks. Suppose
we want to get the Jobname and Address Space where we're running. Check out
the following PL/1, C, COBOL and REXX examples.
/*=============================================
Storage Definitions
==============================================*/
/* --- Map PSA ------------------------------------------ */
Dcl 1 psa Based(psap),
3 psastuff char(548), /* fill 548 bytes */
3 psaaold Pointer;
/* (ignore rest of PSA) */
/* --- Map ASCB------------------------------------------ */
Dcl 1 ascb Based(psaaold),
3 ascbstuff char(172), /* fill 172 bytes */
3 ascbjbni Pointer,
3 ascbjbns Pointer;
/* (ignore rest of ASCB) */
Dcl STCName char(8) Based(ascbjbns);
Dcl JobName char(8) Based(ascbjbni);
/*=============================================
Main Program
==============================================*/
psap = null();
Display ('(DZSPLI) STC: ' || STCName);
Display ('(DZSPLI) Job: ' || JobName);
End DZSPLI;
Figure 2: PL/1 Code Fragment |
DATA DIVISION.
Linkage Section.
* --- Map PSA --------------------------------------
01 PSA.
02 filler pic x(548).
02 PSAAOLD pointer.
* --- Map ASCB -------------------------------------
01 ASCB.
02 filler pic x(172).
02 ASCBJBNI pointer.
02 ASCBJBNS pointer.
01 STCNAME pic x(8).
01 JOBNAME pic x(8).
PROCEDURE DIVISION.
SET ADDRESS OF PSA TO NULL.
SET ADDRESS OF ASCB TO PSAAOLD.
SET ADDRESS OF JOBNAME TO ASCBJBNI.
SET ADDRESS OF STCNAME TO ASCBJBNS.
DISPLAY "(DZSCOB1) " STCNAME ", " JOBNAME.
GOBACK.
Figure 3: COBOL Code Fragment |
/*=============================================
Map z/OS Control Blocks
==============================================*/
/* --- Map PSA --------------------------------- */
struct psa {
int psastuff[4]; /* 4 bytes before CVT Ptr*/
struct cvt *psacvt;
/* Ignore the rest of the PSA */
};
/* --- Map ASCB -------------------------------- */
struct ascb {
char ascbstuff[172]; /* 140 bytes before ptr */
char *ascbjbni; /* Jobname (if any) */
char *ascbjbns; /* STC Name */
/* Ignore the rest of the CVT */
};
struct psa *psa_ptr = 0; /* PSA is at address 0 */
char stcname[10], jobname[10];
/*=============================================
Main Program
==============================================*/
strncpy(jobname,psa_ptr->psaaold->ascbjbni,8);
strncpy(stcname,psa_ptr->psaaold->ascbjbns,8);
printf("Jobname: %s, STCName: %s\n", jobname, stcname);
Figure 4: C Code Fragment |
/* Rexx */
/* --- Get Address of ASCB ----------------------- */
ASCB_Addr = C2D(Storage(224,4)) /* Get address of ASCB */
/* --- First check ASCBJBNI for Jobname ------------------- */
Interpret "JobAddr = Storage("D2X(ASCB_ADDR+172)",4)"
If C2D(JobAddr) = 0 Then
/* --- Not in initiator, so get jobname from ASCBJBNS -- */
Interpret "JobAddr = Storage("D2X(ASCB_ADDR+176)",4)"
Interpret "Job = Storage("C2X(JobAddr)",8)"
say "Jobname: " Job
exit
Figure 5: REXX Code Fragment |
All of these programs use the PSAAOLD field in the PSA to get the address of
the current ASCB, then get both the Jobname (which will only exist if the code
is running in a batch job or something similar that runs in an initiator) and
the started task name.
The problem with using high level languages is that IBM doesn't supply a way
of mapping the control blocks in these languages - only Assembler. So you need
to map them yourself, and we've done this in the above examples. However if
you're using the IBM C compiler, there is a batch utility that converts Assembler
macros to C defines.
Summary
Many z/OS control blocks are chained off two basic blocks: the PSA and CVT.
You can quite easily access these control blocks not only from Assembler programs,
but from High Level languages like C, PL/1 and COBOL.
David Stephens
|
Home
| Press
Room | Contact
Us | Site
Map
