IPLINFO

/* REXX */
/* */
/* AUTHOR: Mark Zelden */
/* */
/* Trace ?r */
/* ============================================================ */
/* */
/* NOTE TO SELF: */
/* */
/* Don't forget to check / update the JES2 node offset table */
/* for each new OS release and the JES3 FMID table. */
/* */
/* ============================================================ */
/* */
/*********************************************************************/
/* */
/* D I S C L A I M E R */
/* ------------------- */
/* */
/* This program is FREEWARE. Use at your own risk. Neither Mark */
/* Zelden, nor other contributing organizations or individuals */
/* accept any liability of any kind howsoever arising out of the use */
/* of this program. You are free to use and modify this program as */
/* you desire, however, the author does ask that you leave his name */
/* in the source and give credit to him as the original programmer. */
/* */
/*********************************************************************/
/* IPLINFO: DISPLAY SYSTEM INFORMATION ON TERMINAL */
/*********************************************************************/
/* */
/* IPLINFO can be called as an interactive exec / ISPF edit macro */
/* or in batch to display various system information. The result */
/* will be displayed in an ISPF browse data set if ISPF is active. */
/* */
/* IPLINFO can also be called as a REXX function to return from 1 */
/* to 20 variables used in the exec at their final value. If more */
/* than one variable is requested the variables are returned with */
/* a blank or user defined delimiter between each variable so they */
/* may be parsed if desired. */
/* */
/* See below for the sytax of each method. */
/* */
/*********************************************************************/
/* */
/* EXECUTION SYNTAX: */
/* */
/* TSO %IPLINFO <option> */
/* */
/* VALID OPTIONS ARE 'ALL', 'IPL', 'VERsion', 'STOrage', 'CPU', */
/* 'IPA', 'SYMbols', 'VMAp', 'PAGe', 'SMF', 'SUB', */
/* 'ASId', 'LPA', 'LNKlst', 'APF' and 'SVC' */
/* */
/* ** 'ALL' is the default option */
/* ** Options may be abbreviated by using 3 or more characters */
/* */
/* ** A 2nd parameter option of 'NOBrowse' may also be specified to */
/* eliminate browsing the output even when ISPF is active. This */
/* will allow any IPLINFO output to be trapped and parsed from */
/* another exec or edit macro if desired. The 'NOBrowse' option */
/* can also be specified as the only option and it will produce */
/* all IPLINFO output without browsing it. */
/* */
/* ** A 2nd parameter option of 'EDIt' may also be specified to */
/* EDIT the output instead of browsing it. The 'EDIt' option */
/* can also be specified as the only option and it will produce */
/* all IPLINFO output without editing it. */
/* */
/* ** The following options are not documented above as standard */
/* options nor in the help panel: */
/* "ASVt" - an alias for the "ASId" option */
/* "ASM" - an alias for the "PAGE" option */
/* "SSI" - an alias for the "SUB" option */
/* "SSN" - an alias for the "SUB" option */
/* "STOre" - an alias for the "STORage" option */
/* "MEMory" - an alias for the "STORage" option */
/* "SUBsystems" - an alias for the "SUB" option */
/* "NOBrowse" - the NOBrowse option */
/* "EDIt" - the EDIt option */
/* */
/* Examples: */
/* TSO %IPLINFO (Display all information) */
/* TSO %IPLINFO VMAP (Display a Virtual Storage Map) */
/* TSO %IPLINFO SYM (Display Static System Symbols) */
/* TSO %IPLINFO SUB (Display Subsystem Information) */
/* TSO %IPLINFO APF (Display APF Library List) */
/* TSO %IPLINFO ALL NOB (Display all infomation, don't browse O/P) */
/* TSO %IPLINFO SUB NOB (Display subsys info, don't browse O/P) */
/* TSO %IPLINFO NOBROWSE (Display all infomation, don't browse O/P) */
/* TSO %IPLINFO ALL EDI (Display all infomation, edit O/P) */
/* TSO %IPLINFO SUB EDI (Display subsys info, edit O/P) */
/* TSO %IPLINFO EDIT (Display all infomation, edit O/P) */
/* */
/* Edit macro invocation: */
/* IPLINFO (Display all information) */
/* IPLINFO VMAP (Display a Virtual Storage Map) */
/* IPLINFO SYM (Display Static System Symbols) */
/* IPLINFO SUB (Display Subsystem Information) */
/* IPLINFO APF (Display APF Library List) */
/* IPLINFO ALL NOB (Display all infomation, don't browse O/P) */
/* IPLINFO SUB NOB (Display subsys info, don't browse O/P) */
/* IPLINFO NOBROWSE (Display all infomation, don't browse O/P) */
/* IPLINFO ALL EDIT (Display all infomation, edit O/P) */
/* IPLINFO SUB EDIT (Display subsys info, edit O/P) */
/* IPLINFO EDIT (Display all infomation, edit O/P) */
/* */
/* Sample Unix System Services WEB Server execution via links: */
/* <a href="/cgi-bin/iplinfo">MVS Information</a> */
/* <a href="/cgi-bin/iplinfo?vmap">Virtual Storage Map</a> */
/* <a href="/cgi-bin/iplinfo?symbols">Static System Symbols</a> */
/* <a href="/cgi-bin/iplinfo?sub">Subsystem Information</a> */
/* <a href="/cgi-bin/iplinfo?apf">APF Library List</a> */
/* */
/*********************************************************************/
/* */
/* FUNCTION SYNTAX: */
/* */
/* IPLINFO(VAR,var1_name) */
/* IPLINFO(VAR,var1_name,var2_name,var3_name, ... var20_name) */
/* */
/* Examples: */
/* sysname = IPLINFO(VAR,GRSNAME) */
/* pvtsize = IPLINFO(VAR,GDAPVTSZ) */
/* */
/* */
/* /* REXX one line IPL information using IPLINFO rexx function */ */
/* IPL_SUM = IPLINFO(VAR,ipldate,ipltime,iplvol,ipladdr,iplparm) */
/* Parse var IPL_SUM ipldate ipltime iplvol ipladdr iplparm */
/* Say 'Date:'ipldate ' Time:'ipltime ' Vol:'iplvol , */
/* ' Load addr:'ipladdr ' LOADPARM:'iplparm */
/* */
/* */
/* NOTE: The default delimeter between returned variables is a */
/* blank. However, this can be problematic when the returned */
/* value contains a blank or is null. You can optionally */
/* change the delimiter from a blank to one of your choice */
/* by using "VAR2" instead of "VAR" in the function call and */
/* specifying the delimiter character(s) as the next operand */
/* prior to the list of variables you want returned. */
/* */
/* */
/* FUNCTION SYNTAX - "VAR2" / USER DEFINED DELIMITER: */
/* */
/* IPLINFO(VAR2,'dlm',var1_name) */
/* IPLINFO(VAR2,'dlm',var1_name,var2_name,var3_name, ... var20_name) */
/* */
/* Example: */
/* /* REXX one line IPL information using IPLINFO rexx function */ */
/* IPL_SUM = IPLINFO(VAR2,'@@',ipldate,ipltime,iplvol, , */
/* ipladdr,iplparm) */
/* Parse var IPL_SUM ipldate '@@' ipltime '@@' iplvol '@@' , */
/* ipladdr '@@' iplparm */
/* Say 'Date:'ipldate ' Time:'ipltime ' Vol:'iplvol , */
/* ' Load addr:'ipladdr ' LOADPARM:'iplparm */
/* */
/*********************************************************************/
/* */
/* NOTE: The dynamic APF and dynamic LNKLST code in this exec */
/* use undocumented IBM control blocks and may break at */
/* any time! */
/* ... tested on MVS ESA V4.3 up through z/OS 2.1. */
/* */
/* NOTE: The LNKLST SET displayed is the LNKLST SET of the address */
/* space running this exec, not necessarily the most */
/* current one. For the current LNKLST SET either: */
/* 1) Run this exec in batch. */
/* 2) Log off and on TSO before executing this exec. */
/* 3) Issue SETPROG LNKLST,UPDATE,JOB=userid (B4 execution) */
/* */
/* NOTE: The APF flag in the LNKLST display is the status if the */
/* data set is accessed VIA LNKLST. Therefore, if IEASYSxx */
/* specifies LNKAUTH=LNKLST, all entires are marked as APF=Y. */
/* */
/*********************************************************************/
LASTUPD = '06/17/2019' /* date of last update */
/*********************************************************************/
/* */
/* B E G I N C U S T O M I Z A T I O N S E C T I O N */
/* */
/* You may changes the variables below to your preference. */
/* You may only choose the options that are commented out. */
/* */
/* DATEFMT - Controls date format: ISO ; USA ; EUR */
/* VMAP - Controls VMAP order: HIGHFIRST ; LOWFIRST */
/* */
/*********************************************************************/
DATEFMT = 'ISO' /* ISO 8601 format YYYY-MM-DD (new default) */
/* DATEFMT = 'USA' */ /* USA format MM/DD/YYYY (original format) */
/* DATEFMT = 'EUR' */ /* EUR format DD/MM/YYYY */
/*********************************************************************/
VMAP = 'HIGHFIRST' /* new default - show VMAP from top down */
/* VMAP = 'LOWFIRST' */ /* the old way - show from bottom up */
/* Please let me know if you "need" the old way (LOWFIRST) as I */
/* will probably remove the duplicate code in the future. */
/*********************************************************************/
/* */
/* E N D C U S T O M I Z A T I O N S E C T I O N */
/* */
/*********************************************************************/
Signal On Syntax name SIG_ALL /* trap syntax errors */
Signal On Novalue name SIG_ALL /* trap uninitialized variables */
Arg OPTION,VAR.1,VAR.2,VAR.3,VAR.4,VAR.5,VAR.6,VAR.7,VAR.8,VAR.9, ,
VAR.10,VAR.11,VAR.12,VAR.13,VAR.14,VAR.15,VAR.16,VAR.17,VAR.18, ,
VAR.19,VAR.20,VAR.21
Parse source . EXEC_TYPE . . . . . ENV . .
MML = Substr(LASTUPD,1,2) /* MM from MM/DD/YYYY */
DDL = Substr(LASTUPD,4,2) /* DD from MM/DD/YYYY */
YYYYL = Substr(LASTUPD,7,4) /* YYYY from MM/DD/YYYY */
If DATEFMT = 'USA' then , /* USA format date? */
LASTUPD = LASTUPD /* date as MM/DD/YYYY */
If DATEFMT = 'EUR' then , /* EUR format date? */
LASTUPD = DDL'/'MML'/'YYYYL /* date as DD/MM/YYYY */
If DATEFMT = 'ISO' then , /* ISO format date? */
LASTUPD = YYYYL'-'MML'-'DDL /* date as YYYY-MM-DD */
SYSISPF = 'NOT ACTIVE' /* set SYSISPF=NOT ACTIVE */
FUNCDLM = ' ' /* Delimiter default for function call */
If ENV <> 'OMVS' then /* are we under unix ? */
If Sysvar('SYSISPF')='ACTIVE' then do /* no, is ISPF active? */
If Pos('NOB',OPTION) = 0 then , /* NOBrowse not used? */
Address ISREDIT "MACRO (OPTION)" /* YES,allow use as macro */
OPTION = Translate(OPTION) /* ensure upper case for edit macro */
Address ISPEXEC "VGET ZENVIR" /* ispf version */
SYSISPF = 'ACTIVE' /* set SYSISPF = ACTIVE */
End
/*********************************************************************/
/* Process options */
/*********************************************************************/
BROWSEOP = 'YES' /* default is to browse OP under ISPF */
EDITOP = 'NO' /* output is not in edit mode */
/*********************************************************************/
If SYSISPF = 'NOT ACTIVE' & Pos('EDI',OPTION) <> 0 then /* EDIT is */
call INVALID_OPTION /* not valid if ISPF isn't active */
If OPTION = '' then OPTION = 'ALL' /* Default option. Change to IPL */
/* or something else - may want to change help panel if changed */
If Abbrev('NOBROWSE',OPTION,3) = 1 then , /* NOBROWSE only opt? */
OPTION = 'ALL NOBROWSE' /* yes, use all option */
If Abbrev('EDIT',OPTION,3) = 1 then , /* EDITonly opt? */
OPTION = 'ALL EDIT' /* yes, use all option */
If Abbrev('NOBROWSE',Word(OPTION,2),3) = 1 then do /* NOBROWSE USED? */
OPTION = Word(OPTION,1) /* separate out option */
BROWSEOP = 'NO' /* set BROWSEOP flag to NO */
End
If Abbrev('EDIT',Word(OPTION,2),3) = 1 then do /* EDIT USED? */
OPTION = Word(OPTION,1) /* separate out option */
EDITOP = 'YES' /* set EDITOP flag to YES */
End
/*********************************************************************/
If OPTION <> 'IPL' & , /* check for IPL option */
Abbrev('VERSION',OPTION,3) <> 1 & , /* check for VERsion option */
Abbrev('STORAGE',OPTION,3) <> 1 & , /* check for STOrage option */
Abbrev('STORE',OPTION,3) <> 1 & , /* check for STOre option */
Abbrev('MEMORY',OPTION,3) <> 1 & , /* check for MEMory option */
OPTION <> 'CPU' & , /* check for CPU option */
OPTION <> 'IPA' & , /* check for IPA option */
Abbrev('SYMBOLS',OPTION,3) <> 1 & , /* check for SYMbols option */
Abbrev('VMAP',OPTION,3) <> 1 & , /* check for VMAp option */
Abbrev('PAGE',OPTION,3) <> 1 & , /* check for PAGe option */
Abbrev('ASM',OPTION,3) <> 1 & , /* check for ASM option */
Abbrev('AUX',OPTION,3) <> 1 & , /* check for ASM option */
OPTION <> 'SMF' & , /* check for SMF option */
OPTION <> 'SSI' & , /* check for SSI option */
OPTION <> 'SSN' & , /* check for SSN option */
OPTION <> 'SUB' & , /* check for SUB option */
Abbrev('SUBSYSTEMS',OPTION,3) <> 1 & , /* check for SUB option */
Abbrev('ASID',OPTION,3) <> 1 & , /* check for ASId option */
Abbrev('ASVT',OPTION,3) <> 1 & , /* check for ASVt option */
OPTION <> 'LPA' & , /* check for LPA option */
Abbrev('LNKLST',OPTION,3) <> 1 & , /* check for LNKlst option */
Abbrev('LINKLIST',OPTION,3) <> 1 & , /* check for LINklist option*/
OPTION <> 'APF' & , /* check for APF option */
OPTION <> 'SVC' & , /* check for SVC option */
OPTION <> 'ALL' & , /* check for ALL option */
Substr(OPTION,1,3) <> 'VAR' , /* check for VAR option */
then call INVALID_OPTION /* no valid option... */
Numeric digits 20 /* dflt of 9 not enough */
/* 20 can handle 64-bit */
Call COMMON /* control blocks needed by multiple routines */
Call HEADING /* Heading sub-routine */
Select
When OPTION = 'ALL' | Substr(OPTION,1,3) = 'VAR' then do
Call IPL /* IPL information */
Call VERSION /* Version information */
Call STOR /* Storage information */
Call CPU /* CPU information */
Call IPA /* Initialization info. */
Call SYMBOLS /* Symbols information */
Call VMAP /* Virt. Storage Map */
Call PAGE /* Page DSN information */
Call SMF /* SMF DSN information */
Call SUB /* Subsystem information */
Call ASID /* ASID usage information*/
Call LPA /* LPA List information */
Call LNKLST /* LNKLST information */
Call APF /* APF List information */
Call SVC /* SVC information */
End /* when OPTION = 'ALL' */
When Abbrev('VERSION',OPTION,3) = 1 then call VERSION
When Abbrev('STORAGE',OPTION,3) = 1 then call STOR
When Abbrev('STORE',OPTION,3) = 1 then call STOR
When Abbrev('MEMORY',OPTION,3) = 1 then call STOR
When Abbrev('SYMBOLS',OPTION,3) = 1 then call SYMBOLS
When Abbrev('VMAP',OPTION,3) = 1 then call VMAP
When Abbrev('ASM',OPTION,3) = 1 then call PAGE
When Abbrev('AUX',OPTION,3) = 1 then call PAGE
When Abbrev('SSI',OPTION,3) = 1 then call SUB
When Abbrev('SSN',OPTION,3) = 1 then call SUB
When Abbrev('SUBSYSTEMS',OPTION,3) = 1 then call SUB
When Abbrev('PAGE',OPTION,3) = 1 then call PAGE
When Abbrev('ASID',OPTION,3) = 1 then call ASID
When Abbrev('ASVT',OPTION,3) = 1 then call ASID
When Abbrev('LNKLST',OPTION,3) = 1 then call LNKLST
When Abbrev('LINKLIST',OPTION,3) = 1 then call LNKLST
Otherwise interpret "Call" OPTION
End /* select */
/*********************************************************************/
/* Done looking at all control blocks */
/*********************************************************************/
/*********************************************************************/
/* IPLINFO called as a function with an alternate delimiter. */
/* Return variable names and exit */
/*********************************************************************/
If Substr(OPTION,1,4) = 'VAR2' & EXEC_TYPE='FUNCTION' then do
"DROPBUF" /* remove data stack */
FUNCDLM = VAR.1 /* function delimiter */
ALL_VARS = Value(VAR.2) /* at least one var */
Do V = 3 to 21 /* check for others */
If VAR.V = '' then leave /* done, leave loop */
Else ALL_VARS = ALL_VARS || , /* concat additional */
FUNCDLM || Value(VAR.V) /* var + dlm at end */
End /* end Do V */
Return ALL_VARS /* return vars */
End
/*********************************************************************/
/* IPLINFO called as a function. Return variable names and exit */
/*********************************************************************/
If Substr(OPTION,1,3) = 'VAR' & EXEC_TYPE='FUNCTION' then do
"DROPBUF" /* remove data stack */
ALL_VARS = Value(VAR.1) /* at least one var */
Do V = 2 to 20 /* check for others */
If VAR.V = '' then leave /* done, leave loop */
Else ALL_VARS = ALL_VARS || , /* concat additional */
FUNCDLM || Value(VAR.V) /* var + dlm at end */
End /* end Do V */
Return ALL_VARS /* return vars */
End
/*********************************************************************/
/* If ISPF is active and the BROWSEOP option is set (default) then */
/* browse the output - otherwise write to the terminal */
/*********************************************************************/
If SYSISPF = 'ACTIVE' & BROWSEOP = 'YES' , /* ISPF active and */
then call BROWSE_ISPF /* BROWSEOP option set? */
Else do queued() /* ISPF is not active */
Parse pull line /* pull queued lines */
Say line /* say lines */
End /* else do */
Exit 0 /* End IPLINFO - RC 0 */
/*********************************************************************/
/* End of main IPLINFO code */
/*********************************************************************/
/*********************************************************************/
/* Start of sub-routines */
/*********************************************************************/
INVALID_OPTION: /* Invalid option sub-routine */
If SYSISPF = 'ACTIVE' then do
Queue ' '
Queue ' ******************************************************'
If OPTION <> '?' then,
Queue ' * Invalid IPLINFO option. *'
Queue ' * Please hit PF1/HELP two times for valid options. *'
Queue ' ******************************************************'
Queue ' '
OPTION = 'Invalid'
Call BROWSE_ISPF
Exit 16
End
Else do
Call CKWEB /* call CKWEB sub-routine */
Say Copies('*',79)
Say " "
If OPTION <> '?' then,
Say "Invalid IPLINFO option."
Say " "
Say "EXECUTION SYNTAX: %IPLINFO <option>"
Say " "
Say "VALID OPTIONS ARE 'ALL', 'IPL', 'VERsion'," ,
"'STOrage', 'CPU', 'IPA', 'SYMbols',"
Say " 'VMAp', 'PAGe', 'SMF', 'SUB'," ,
"'ASId', 'LPA', 'LNKlst' or 'LINklist' and 'APF'"
Say " "
Say "** 'ALL' is the default option"
Say "** OPTIONS may be abbreviated by using 3 or more characters"
Say " "
Say Copies('*',79)
If OPTION = '?' then Exit 0
Else exit 16
End
return
HEADING: /* Heading sub-routine */

Call CKWEB /* call CKWEB sub-routine */
Call RDATE 'TODAY' /* call RDATE sub-routine */
DAY = Word(RESULT,3) /* weekday from RDATE */
MMT = Substr(RESULT,1,2) /* MM from MM/DD/YYYY */
DDT = Substr(RESULT,4,2) /* DD from MM/DD/YYYY */
YYYYT = Substr(RESULT,7,4) /* YYYY from MM/DD/YYYY */
DATE = Substr(RESULT,1,10) /* date as MM/DD/YYYY */
DATE = DDT'/'MMT'/'YYYYT /* date as DD/MM/YYYY */
DATE = YYYYT'-'MMT'-'DDT /* date as YYYY-MM-DD */
JUL = Substr(RESULT,7,8) /* date as YYYY.DDD */
CURNNNNN = Substr(RESULT,16,5) /* date as NNNNN */
Queue Copies('*',79)
Queue Copies('*',15) || ,
Center('IPLINFO - SYSTEM INFORMATION FOR' GRSNAME,49) || ,
Copies('*',15)
Queue Copies('*',79)
Queue ' '
Queue 'Today is 'DAY DATE '('JUL'). The local time is 'TIME()'.'
Return
CKWEB: /* Create HTML needed for web page output sub-routine */

If ENV = 'OMVS' then do /* Are we under OMVS? */
Do CKWEB = __ENVIRONMENT.0 to 1 by -1 /* check env. vars */
If pos('HTTP_',__ENVIRONMENT.CKWEB) <> 0 then do /* web server */
Say 'Content-type: text/html'
Say ''
Say '<title>Mark''s MVS Utilities - IPLINFO</title>'
Say '<meta name="author" content="Mark Zelden -' ,
'mark@mzelden.com">'
Say '<meta name="description" content="' || ,
'IPLINFO -' OPTION 'option.' ,
'Last updated on' LASTUPD ||'. Written by' ,
'Mark Zelden. Mark''s MVS Utilities -' ,
'http://www.mzelden.com/mvsutil.html">'
Say '<meta http-equiv="pragma" content="no-cache">'
Say '<body BGCOLOR="#000000" TEXT="#00FFFF">'
Say '<pre>'
Leave /* exit loop */
End /* if pos */
End /* do CKWEB */
End
Return
COMMON: /* Control blocks needed by multiple routines */

CVT = C2d(Storage(10,4)) /* point to CVT */
CVTFLAG2 = Storage(D2x(CVT+377),1) /* CVT flag byte 2 */
CVTEXT2 = C2d(Storage(D2x(CVT + 328),4)) /* point to CVTEXT2 */
PRODNAME = Storage(D2x(CVT - 40),7) /* point to mvs version */
If Substr(PRODNAME,3,1) >= 3 then do /* HBB3310 ESA V3 & > */
CVTOSLV0 = Storage(D2x(CVT + 1264),1) /* Byte 0 of CVTOSLVL */
End
If Bitand(CVTOSLV0,'08'x) = '08'x then , /* HBB4410 ESA V4 & > */
ECVT = C2d(Storage(D2x(CVT + 140),4)) /* point to CVTECVT */
FMIDNUM = Storage(D2x(CVT - 32),7) /* point to fmid */
JESCT = C2d(Storage(D2x(CVT + 296),4)) /* point to JESCT */
JESCTEXT = C2d(Storage(D2x(JESCT +100),4)) /* point to JESPEXT */
JESPJESN = Storage(D2x(JESCT + 28),4) /* name of primary JES */
CVTSNAME = Storage(D2x(CVT + 340),8) /* point to system name */
GRSNAME = Strip(CVTSNAME,'T') /* del trailing blanks */
CSD = C2d(Storage(D2x(CVT + 660),4)) /* point to CSD */
SMCA = Storage(D2x(CVT + 196),4) /* point to SMCA */
SMCA = Bitand(SMCA,'7FFFFFFF'x) /* zero high order bit */
SMCA = C2d(SMCA) /* convert to decimal */
ASMVT = C2d(Storage(D2x(CVT + 704),4)) /* point to ASMVT */
CVTSCPIN = D2x(CVT+832) /* point to SCPINFO */
If Bitand(CVTOSLV5,'08'x) = '08'x then do /* z/OS 1.10 and above */
ECVTSCPIN = D2x(ECVT+876) /* point to cur SCPINFO */
SCCB = C2d(Storage(ECVTSCPIN,4)) /* Service Call Cntl Blk*/
End
Else SCCB = C2d(Storage(CVTSCPIN,4)) /* Service Call Cntl Blk*/
RCE = C2d(Storage(D2x(CVT + 1168),4)) /* point to RCE */
MODEL = C2d(Storage(D2x(CVT - 6),2)) /* point to cpu model */
/*********************************************************************/
/* The CPU model is stored in packed decimal format with no sign, */
/* so to make the model printable, it needs to be converted back */
/* to hex. */
/*********************************************************************/
MODEL = D2x(MODEL) /* convert back to hex */
PCCAVT = C2d(Storage(D2x(CVT + 764),4)) /* point to PCCA vect tb*/
If Bitand(CVTOSLV1,'01'x) = '01'x then do /* OS/390 R2 and above */
ECVTIPA = C2d(Storage(D2x(ECVT + 392),4)) /* point to IPA */
IPASCAT = Storage(D2x(ECVTIPA + 224),63) /* SYSCAT card image */
End
zARCH = 1 /* default ARCHLVL */
FLCARCH = Storage('A3',1) /* FLCARCH in PSA */
If C2d(FLCARCH) <> 0 then zARCH=2 /* non-zero is z/Arch. */
End
Return
IPL: /* IPL information sub-routine */

Queue ' '
/*********************************************************************/
/* The IPL date is stored in packed decimal format - so to make */
/* the date printable, it needs to be converted back to hex and */
/* the packed sign needs to be removed. */
/*********************************************************************/
/* Converting binary fields to time of day format is described */
/* in the MVS SMF manual. */
/*********************************************************************/
IPLTIME = C2d(Storage(D2x(SMCA + 336),4)) /* IPL Time - binary */
IPLDATE = C2d(Storage(D2x(SMCA + 340),4)) /* IPL Date - 0CYYDDDF */
If IPLDATE >= 16777231 then do /* is C = 1 ? */
IPLDATE = D2x(IPLDATE) /* convert back to hex */
IPLDATE = Substr(IPLDATE,2,5) /* keep YYDDD */
IPLDATE = '20'IPLDATE /* use 21st century date*/
End
Else do
IPLDATE = D2x(IPLDATE) /* convert back to hex */
IPLDATE = Left(IPLDATE,5) /* keep YYDDD */
IPLDATE = '19'IPLDATE /* use 20th century date*/
End
IPLYYYY = Substr(IPLDATE,1,4) /* YYYY portion of date */
IPLDDD = Substr(IPLDATE,5,3) /* DDD portion of date */
Call RDATE IPLYYYY IPLDDD /* call RDATE subroutine*/
IPLDAY = Word(RESULT,3) /* weekday from RDATE */
MMI = Substr(RESULT,1,2) /* MM from MM/DD/YYYY */
DDI = Substr(RESULT,4,2) /* DD from MM/DD/YYYY */
YYYYI = Substr(RESULT,7,4) /* YYYY from MM/DD/YYYY */
IPLDATE = Substr(RESULT,1,10) /* date as MM/DD/YYYY */
IPLDATE = DDI'/'MMI'/'YYYYI /* date as DD/MM/YYYY */
IPLDATE = YYYYI'-'MMI'-'DDI /* date as YYYY-MM-DD */
IPLJUL = Substr(RESULT,7,8) /* date as YYYY.DDD */
IPLNNNNN = Substr(RESULT,16,5) /* date as NNNNN */
IPLHH = Right(IPLTIME%100%3600,2,'0') /* IPL hour */
IPLMM = Right(IPLTIME%100//3600%60,2,'0') /* IPL minute */
IPLSS = Right(IPLTIME%100//60,2,'0') /* IPL seconds */
IPLTIME = IPLHH':'IPLMM':'IPLSS /* time in HH:MM:SS */
/* */
ASMFLAG2 = Storage(D2x(ASMVT + 1),1) /* point to ASMFLAG2 */
If Bitand(ASMFLAG2,'08'x) = '08'x then , /* Check ASMQUICK bit */
IPLCLPA = 'without CLPA' /* bit on - no CLPA */
Else IPLCLPA = 'with CLPA' /* bit off - CLPA */
RESUCB = C2d(Storage(D2x(JESCT + 4),4)) /* point to SYSRES UCB */
IPLVOL = Storage(D2x(RESUCB + 28),6) /* point to IPL volume */
If Bitand(CVTOSLV1,'20'x) <> '20'x then , /* Below HBB5510 ESA V5 */
IPLADDR = Storage(D2x(RESUCB + 13),3) /* point to IPL address */
Else do
CVTSYSAD = C2d(Storage(D2x(CVT + 48),4)) /* point to UCB address */
IPLADDR = Storage(D2x(CVTSYSAD + 4),2) /* point to IPL UCB */
IPLADDR = C2x(IPLADDR) /* convert to EBCDIC */
End
SMFNAME = Storage(D2x(SMCA + 16),4) /* point to SMF name */
SMFNAME = Strip(SMFNAME,'T') /* del trailing blanks */
AMCBS = C2d(Storage(D2x(CVT + 256),4)) /* point to AMCBS */
If Bitand(CVTOSLV2,'80'x) <> '80'x then do /*Use CAXWA B4 OS/390 R4*/
ACB = C2d(Storage(D2x(AMCBS + 8),4)) /* point to ACB */
CAXWA = C2d(Storage(D2x(ACB + 64),4)) /* point to CAXWA */
MCATDSN = Storage(D2x(CAXWA + 52),44) /* master catalog dsn */
MCATDSN = Strip(MCATDSN,'T') /* remove trailing blnks*/
MCATUCB = C2d(Storage(D2x(CAXWA + 28),4)) /* point to mcat UCB */
MCATVOL = Storage(D2x(MCATUCB + 28),6) /* master catalog VOLSER*/
End
Else do /* OS/390 R4 and above */
MCATDSN = Strip(Substr(IPASCAT,11,44)) /* master catalog dsn */
MCATVOL = Substr(IPASCAT,1,6) /* master catalog VOLSER*/
IPASCANL = Storage(d2x(ECVTIPA+231),1) /* mcat alias level */
IPASCTYP = Storage(d2x(ECVTIPA+230),1) /* mcat catalog type */
AMCBSFLG = Storage(D2x(AMCBS + 96),1) /* AMCBS flags */
AMCBSALV = C2d(Storage(D2x(AMCBS + 155),1)) /* AMCBS - alias level */
If IPASCANL = ' ' then IPASCANL = 1 /* SYSCAT col 17 blank / dflt */
If IPASCTYP = ' ' then IPASCTYP = 1 /* SYSCAT col 16 blank / dflt */
CTYP.0 = 'VSAM'
CTYP.1 = 'ICF. SYS%-SYS1 conversion was not active at IPL time'
CTYP.2 = 'ICF. SYS%-SYS1 conversion was active at IPL time'
End
Queue 'The last IPL was 'IPLDAY IPLDATE '('IPLJUL')' ,
'at 'IPLTIME' ('CURNNNNN - IPLNNNNN' days ago).'
Queue 'The IPL was done 'IPLCLPA'.'
Queue 'The system IPL address was 'IPLADDR' ('IPLVOL').'
If Bitand(CVTOSLV0,'08'x) = '08'x then do /* HBB4410 ESA V4 1 & > */
ECVTSPLX = Storage(D2x(ECVT+8),8) /* point to SYSPLEX name*/
ECVTLOAD = Storage(D2x(ECVT+160),8) /* point to LOAD PARM */
IPLPARM = Strip(ECVTLOAD,'T') /* del trailing blanks */
SEPPARM = Substr(IPLPARM,1,4) Substr(IPLPARM,5,2),
Substr(IPLPARM,7,1) Substr(IPLPARM,8,1)
SEPPARM = Strip(SEPPARM,'T') /* del trailing blanks */
Queue 'The IPL LOAD PARM used was 'IPLPARM' ('SEPPARM').'
If Bitand(CVTOSLV1,'20'x) = '20'x then do /* HBB5510 ESA V5 & > */
CVTIXAVL = C2d(Storage(D2x(CVT+124),4)) /* point to IOCM */
IOCIOVTP = C2d(Storage(D2x(CVTIXAVL+208),4)) /* IOS Vector Table */
CDA = C2d(Storage(D2x(IOCIOVTP+24),4)) /* point to CDA */
End
CVTTZ = Storage(D2x(CVT + 304),4) /* point to cvttz */
CKTZBYTE = Storage(D2x(CVT + 304),1) /* need to chk 1st byte */
If bitand(CKTZBYTE,'80'x) = '80'x then , /* chk for negative */
CVTTZ = C2d(CVTTZ,4) /* negative offset C2d */
Else CVTTZ = C2d(CVTTZ) /* postitive offset C2d */
CVTTZ = CVTTZ * 1.048576 / 3600 /* convert to hours */
If Format(CVTTZ,3,1) = Format(CVTTZ,3,0) , /* don't use decimal if */
then CVTTZ = Strip(Format(CVTTZ,3,0)) /* not needed */
Else CVTTZ = Strip(Format(CVTTZ,3,1)) /* display 1 decimal */
Queue 'The local time offset from GMT time is' CVTTZ 'hours.'
If Bitand(CVTOSLV1,'10'x) = '10'x then do /* HBB5520 ESA V5.2 & > */
ECVTHDNM = Storage(D2x(ECVT+336),8) /* point to hardware nam*/
ECVTLPNM = Storage(D2x(ECVT+344),8) /* point to LPAR name */
If Bitand(CVTOSLV2,'01'x) = '01'x then do /* OS/390 R10 & above */
MIFID = C2d(Storage(D2X(CDA+252),1)) /* MIF ID in decimal */
MIFID = D2x(MIFID) /* MIF ID in hex */
If Bitand(CVTOSLV3,'04'x) = '04'x then do /* z/OS 1.4 and above*/
IOCCSSID = C2d(Storage(d2x(CVTIXAVL+275),1))
IOCCSSID = D2x(IOCCSSID) /* CSS ID in hex */
End
If zARCH = 2 then , /* z/Architechture */
Queue 'The system is running in z/Architecture mode' ,
'(ARCHLVL = 2).'
Else , /* ESA/390 mode */
Queue 'The system is running in ESA/390 mode (ARCHLVL = 1).'
End /* If Bitand(CVTOSLV2,'01'x) = '01'x */
If ECVTHDNM <> ' ' & ECVTLPNM <> ' ' then do
CSDPLPN = C2d(Storage(D2x(CSD + 252),1)) /* point to LPAR #*/
/* CSDPLPN not valid for z990 (T-REX) or z890 for LPAR number */
CPOFF = 0 /* init offset to next PCCA entry */
PCCA = 0 /* init PCCA to 0 */
Do until PCCA <> 0 /* do until we find a valid PCCA */
PCCA = C2d(Storage(D2x(PCCAVT + CPOFF),4)) /* point to PCCA */
If PCCA <> 0 then do
LPAR_# = X2d(Storage(D2x(PCCA + 6),2)) /* LPAR # in hex */
LPAR_# = D2x(LPAR_#) /* display as hex */
End /* if PCCA <> 0 */
Else CPOFF = CPOFF + 4 /* bump up offset for next PCCA */
End /* do until PCCA <> 0 */
If Bitand(CVTOSLV2,'01'x) = '01'x then do /* OS/390 R10 & > */
Queue 'The Processor name is' Strip(ECVTHDNM)'.' ,
'The LPAR name is' Strip(ECVTLPNM)'.'
If Bitand(CVTOSLV3,'04'x) = '04'x then /* z/OS 1.4 and above*/
Queue ' ' Strip(ECVTLPNM) 'is (HMC defined) LPAR ID =' ,
LPAR_#', MIF ID =' mifid 'and CSS ID = 'IOCCSSID'.'
Else ,
Queue ' ' Strip(ECVTLPNM) 'is (HMC defined) LPAR ID =' ,
LPAR_# 'and MIF ID =' mifid'.'
Queue ' ' Strip(ECVTLPNM) 'is PR/SM partition number' ,
CSDPLPN' (internal value from the CSD).'
Else ,
Queue 'The Processor name is' Strip(ECVTHDNM)'.' ,
'The LPAR name is' Strip(ECVTLPNM)' (LPAR #'CSDPLPN').'
End /* If ECVTHDNM <> ' ' & ECVTLPNM <> ' ' */
Else if ECVTHDNM <> ' ' then ,
Queue 'The Processor name is' Strip(ECVTHDNM)'.'
If Bitand(CVTOSLV1,'20'x) = '20'x , /* HBB5510 ESA V5 & above */
& ECVTSPLX <> 'LOCAL' then do /* and not a local sysplex */
JESDSNID = X2d(Storage(D2x(JESCTEXT+120),2)) /*ID for temp dsns*/
Queue 'The sysplex name is' Strip(ECVTSPLX)'. This was system' ,
'number' Format(JESDSNID) 'added to the sysplex.'
Else queue 'The sysplex name is' Strip(ECVTSPLX)'.'
End
Queue 'The GRS system id (SYSNAME) is 'GRSNAME'.'
ECVTGMOD = C2d(Storage(D2x(ECVT + 266),1)) /* GRS mode */
GMOD.0 = "NONE" /* Stem for GRS mode: ECVTGNON EQU 0 */
GMOD.1 = "RING" /* Stem for GRS mode: ECVTGRNG EQU 1 */
GMOD.2 = "STAR" /* Stem for GRS mode: ECVTGSTA EQU 2 */
Queue ' The GRS mode is' GMOD.ECVTGMOD' (NONE, RING or STAR).'
End
Queue 'The SMF system id (SID) is 'SMFNAME'.'
If Bitand(CVTOSLV1,'20'x) <> '20'x then do /* Below HBB5510 ESA V5 */
IOCON = Storage(D2x(CVTEXT2 + 6),2) /* HCD IODFxx or MVSCP*/
/* IOCONFIG ID=xx */
Queue 'The currently active IOCONFIG or HCD IODF is 'IOCON'.'
End
Else do
IODF = Storage(D2X(CDA+32),44) /* point to IODF name */
IODF = Strip(IODF,'T') /* del trailing blanks*/
CONFIGID = Storage(D2X(CDA+92),8) /* point to CONFIG */
EDT = Storage(D2X(CDA+104),2) /* point to EDT */
IOPROC = Storage(D2X(CDA+124),8) /* point to IODF Proc */
IODATE = Storage(D2X(CDA+156),8) /* point to IODF date */
IOTIME = Storage(D2X(CDA+164),8) /* point to IODF time */
IODESC = Storage(D2X(CDA+172),16) /* point to IODF desc */
Queue 'The currently active IODF data set is 'IODF'.'
Queue ' Configuration ID =' CONFIGID ' EDT ID =' EDT
If Substr(IOPROC,1,1) <> '00'x & ,
Substr(IOPROC,1,1) <> '40'x then do /* is token there? */
Queue ' TOKEN: Processor Date Time Description'
Queue ' 'IOPROC' 'IODATE' 'IOTIME' 'IODESC
End
End
Queue 'The Master Catalog is 'MCATDSN' on 'MCATVOL'.'
Queue ' The catalog alias level was 'IPASCANL' at IPL time.'
Queue ' The catalog alias level is currently' AMCBSALV'.'
Queue ' The catalog type is 'CTYP.IPASCTYP'.'
If Bitand(AMCBSFLG,'40'x) = '40'x then ,
Queue ' SYS%-SYS1 conversion is currently active.'
Else ,
Queue ' SYS%-SYS1 conversion is not currently active.'
End
/*If OPTION = 'IPL' then interpret call 'VERSION' */ /* incl version*/
Return
VERSION: /* Version information sub-routine */

Queue ' '
Call SUB 'FINDJES' /* call SUB routine with FINDJES option */
If JESPJESN = 'JES3' then do /* Is this JES3? */
If ENV = 'OMVS' then do /* running under Unix System Services */
JES3FMID = Storage(D2x(JESSSVT+644),8) /* JES3 FMID */
Select /* determine JES3 version from FMID */
When JES3FMID = 'HJS5521' then JESLEV = 'SP 5.2.1'
When JES3FMID = 'HJS6601' then JESLEV = 'OS 1.1.0'
When JES3FMID = 'HJS7705' then JESLEV = 'z 1.2.0'
When JES3FMID = 'HJS77A0' then JESLEV = 'z 2.2.0'
When JES3FMID = 'HJS77B0' then JESLEV = 'z 2.3.0'
Otherwise JESLEV = JES3FMID /* if not in tbl, use FMID as ver */
End /* select */
JESNODE = '*not_avail*' /* can't do under USS */
End /* if env = 'omvs' */
Else do /* if not running under Unix System Services, use TSO VARs */
JESLEV = SYSVAR('SYSJES') /* TSO/E VAR for JESLVL */
JESNODE = SYSVAR('SYSNODE') /* TSO/E VAR for JESNODE*/
End
End
Else do /* JES2 */
JESLEV = Strip(Storage(D2x(JESSUSE),8)) /* JES2 Version */
/* offset in $HCCT - CCTNDENM */
Select
When Substr(JESLEV,1,8) == 'z/OS 2.3' | , /* z/OS 2.3 */
Substr(JESLEV,1,8) == 'z/OS 2.2' then, /* z/OS 2.2 */
JESNODE = Strip(Storage(D2x(JESSUS2+664),8)) /* JES2 NODE */
When Substr(JESLEV,1,8) == 'z/OS 2.1' | , /* z/OS 2.1 */
Substr(JESLEV,1,8) == 'z/OS1.13' | , /* z/OS 1.13 */
Substr(JESLEV,1,8) == 'z/OS1.12' | , /* z/OS 1.12 */
Substr(JESLEV,1,8) == 'z/OS1.11' then, /* z/OS 1.11 */
When Substr(JESLEV,1,8) == 'z/OS1.10' | , /* z/OS 1.10 */
When Substr(JESLEV,1,8) == 'z/OS 1.8' then, /* z/OS 1.8 */
When Substr(JESLEV,1,8) == 'z/OS 1.7' then, /* z/OS 1.7 */
When Substr(JESLEV,1,8) == 'z/OS 1.5' | , /* z/OS 1.5 & 1.6 */
Substr(JESLEV,1,8) == 'z/OS 1.4' then /* z/OS 1.4 */
When Substr(JESLEV,1,7) == 'OS 2.10' | , /* OS/390 2.10 and */
When Substr(JESLEV,1,6) == 'OS 1.1' | , /* OS/390 1.1 or */
Substr(JESLEV,1,4) == 'SP 5' then , /* ESA V5 JES2 */
When Substr(JESLEV,1,5) == 'OS 1.' | , /* OS/390 1.2 */
Substr(JESLEV,1,5) == 'OS 2.' then, /* through OS/390 2.9 */
Otherwise , /* Lower than ESA V5 */
If ENV = 'OMVS' then JESNODE = '*not_avail*'
else JESNODE = SYSVAR('SYSNODE') /* TSO/E VAR for JESNODE*/
End /* select */
End /* else do */
/* */
CVTVERID = Storage(D2x(CVT - 24),16) /* "user" software vers.*/
CVTRAC = C2d(Storage(D2x(CVT + 992),4)) /* point to RACF CVT */
RCVT = CVTRAC /* use RCVT name */
RCVTID = Storage(D2x(RCVT),4) /* point to RCVTID */
/* RCVT, ACF2, or RTSS */
SECNAM = RCVTID /* ACF2 SECNAME = RCVTID*/
If RCVTID = 'RCVT' then SECNAM = 'RACF' /* RCVT is RACF */
If RCVTID = 'RTSS' then SECNAM = 'Top Secret' /* RTSS is Top Secret */
RACFVRM = Storage(D2x(RCVT + 616),4) /* RACF Ver/Rel/Mod */
RACFVER = Substr(RACFVRM,1,1) /* RACF Version */
RACFREL = Substr(RACFVRM,2,2) /* RACF Release */
If Bitand(CVTOSLV2,'01'x) <> '01'x then , /* below OS/390 R10 */
RACFREL = Format(RACFREL) /* Remove leading 0 */
RACFMOD = Substr(RACFVRM,4,1) /* RACF MOD level */
RACFLEV = RACFVER || '.' || RACFREL || '.' || RACFMOD
If RCVTID = 'RCVT' | RCVTID = 'RTSS' then ,
RCVTDSN = Strip(Storage(D2x(RCVT + 56),44)) /* RACF prim dsn or */
/* TSS Security File */
If SECNAM = 'ACF2' then do
SSCVT = C2d(Storage(D2x(JESCT+24),4)) /* point to SSCVT */
Do while SSCVT <> 0
SSCTSNAM = Storage(D2x(SSCVT+8),4) /* subsystem name */
If SSCTSNAM = 'ACF2' then do
ACCVT = C2d(Storage(D2x(SSCVT + 20),4)) /* ACF2 CVT */
ACCPFXP = C2d(Storage(D2x(ACCVT - 4),4)) /* ACCVT prefix */
ACCPIDL = C2d(Storage(D2x(ACCPFXP + 8),2)) /* Len ident area */
LEN_ID = ACCPIDL-4 /* don't count ACCPIDL and ACCPIDO in len */
ACCPIDS = Strip(Storage(D2x(ACCPFXP + 12),LEN_ID)) /*sys ident*/
ACF2DSNS = C2d(Storage(D2x(ACCVT + 252) ,4)) /* ACF2 DSNs */
ACF2DNUM = C2d(Storage(D2x(ACF2DSNS + 16),2)) /* # OF DSNs */
Leave
End
SSCVT = C2d(Storage(D2x(SSCVT+4),4)) /* next sscvt or zero */
End /* Do while SSCVT <> 0 */
End
/* */
CVTDFA = C2d(Storage(D2x(CVT + 1216),4)) /* point to DFP ID table*/
DFAPROD = C2d(Storage(D2x(CVTDFA +16),1)) /* point to product byte*/
If DFAPROD = 0 then do /* DFP not DF/SMS */
DFAREL = C2x(Storage(D2x(CVTDFA+2),2)) /* point to DFP release */
DFPVER = Substr(DFAREL,1,1) /* DFP Version */
DFPREL = Substr(DFAREL,2,1) /* DFP Release */
DFPMOD = Substr(DFAREL,3,1) /* DFP Mod Lvl */
DFPRD = 'DFP' /* product is DFP */
DFLEV = DFPVER || '.' || DFPREL || '.' || DFPMOD
End
Else do /* DFSMS not DFP */
DFARELS = C2x(Storage(D2x(CVTDFA+16),4)) /* point to DF/SMS rel */
DFAVER = X2d(Substr(DFARELS,3,2)) /* DF/SMS Version */
DFAREL = X2d(Substr(DFARELS,5,2)) /* DF/SMS Release */
DFAMOD = X2d(Substr(DFARELS,7,2)) /* DF/SMS Mod Lvl */
DFPRD = 'DFSMS' /* product is DF/SMS */
DFLEV = DFAVER || '.' || DFAREL || '.' || DFAMOD
If DFAPROD = 2 then DFLEV = 'OS/390' DFLEV
If DFAPROD = 3 then do
DFLEV = 'z/OS' DFLEV
/* Next section of code doesn't work because CRT is in key 5 */
/*
CVTCBSP = C2d(Storage(D2x(CVT + 256),4)) /* point to AMCBS */
CRT = C2d(Storage(D2x(CVTCBSP + 124),4)) /* point to CRT */
CRTFMID = Storage(D2x(CRT + 472),7) /* DFSMS FMID */
*/
End /* if DFAPROD = 3 */
JESSMSIB = C2d(Storage(D2x(JESCTEXT+84),4)) /* point to SMS SSIB */
IGDSSIVT = C2d(Storage(D2x(JESSMSIB+32),4)) /* SMS vector table */
IGDSMS = Storage(D2x(IGDSSIVT+132),2) /* IGDSMSxx suffix */
SMSACDS = Strip(Storage(D2x(IGDSSIVT+44),44)) /* ACDS */
SMSCMDS = Strip(Storage(D2x(IGDSSIVT+88),44)) /* COMMDS */
End
/* */
CVTTVT = C2d(Storage(D2x(CVT + 156),4)) /* point to TSO vect tbl*/
TSVTLVER = Storage(D2x(CVTTVT+100),1) /* point to TSO Version */
TSVTLREL = Storage(D2x(CVTTVT+101),2) /* point to TSO Release */
TSVTLREL = Format(TSVTLREL) /* Remove leading 0 */
TSVTLMOD = Storage(D2x(CVTTVT+103),1) /* point to TSO Mod Lvl */
TSOLEV = TSVTLVER || '.' || TSVTLREL || '.' || TSVTLMOD
/* */
CHKVTACT = Storage(D2x(CVTEXT2+64),1) /* VTAM active flag */
If bitand(CHKVTACT,'80'x) = '80'x then do /* vtam is active */
CVTATCVT = C2d(Storage(D2x(CVTEXT2 + 65),3)) /* point to VTAM AVT */
ISTATCVT = C2d(Storage(D2x(CVTATCVT + 0),4)) /* point to VTAM CVT */
ATCVTLVL = Storage(D2x(ISTATCVT + 0),8) /* VTAM Rel Lvl VOVRP */
VTAMVER = Substr(ATCVTLVL,3,1) /* VTAM Version V */
VTAMREL = Substr(ATCVTLVL,4,1) /* VTAM Release R */
VTAMMOD = Substr(ATCVTLVL,5,1) /* VTAM Mod Lvl P */
If VTAMMOD = ' ' then VTAMLEV = VTAMVER || '.' || VTAMREL
else VTAMLEV = VTAMVER || '.' || VTAMREL || '.' || VTAMMOD
/* */
ATCNETID = Strip(Storage(D2x(ISTATCVT + 2080),8)) /* VTAM NETID */
ATCNQNAM = Strip(Storage(D2x(ISTATCVT + 2412),17)) /* VTAM SSCPNAME*/
VTAM_ACTIVE = 'YES'
End /* if bitand (vtam is active) */
Else VTAM_ACTIVE = 'NO'
ECVTTCP = D2x(ECVT + 176) /* TCPIP */
TSAB = C2d(Storage(ECVTTCP,4)) /* point to TSAB */
TSABLEN = C2d(Storage(D2x(TSAB+4),2)) /* Length of TSAB */
TSEBNUM = (TSABLEN - 64) / 128 /* Number of TSEBs */
TCPANUM = 0 /* counter of act TSEBs */
TCP_ACTIVE = 'NO' /* Init active flag */
Do SCNTSEBS = 1 to TSEBNUM /* Scan TSEB loop */
TSEB = TSAB + 64 + (SCNTSEBS-1)*128
TCPASID = C2x(Storage(D2x(TSEB + 56),2)) /* asid or zero */
If TCPASID <> 0 then do /* active asid */
TCP_ACTIVE = 'YES'
TCPANUM = TCPANUM + 1 /* add 1 to active count */
TCPSTATUS = Storage(D2x(TSEB + 8),1)
TCPNAME.TCPANUM = Storage(D2x(TSEB + 16),8)
TCPNUM.TCPANUM = C2x(Storage(D2x(TSEB + 24),1))
TCPVER.TCPANUM = C2x(Storage(D2x(TSEB + 26),2))
TCPASID.TCPANUM = TCPASID '('Right(X2d(TCPASID),4)')'
Select
When Bitand(TCPSTATUS,'80'x) = '80'x then TCPST = 'Active'
When Bitand(TCPSTATUS,'40'x) = '40'x then TCPST = 'Terminating'
When Bitand(TCPSTATUS,'20'x) = '20'x then TCPST = 'Down'
When Bitand(TCPSTATUS,'10'x) = '10'x then TCPST = 'Stopped'
Otherwise say 'Bad TCPSTATUS! Contact Mark Zelden' TCPSTATUS
End /* select */
TCPST.TCPANUM = TCPST
End /* If TCPASID <> 0 */
End /* Do SCNTSEBS = 1 to TSEBNUM */
If Bitand(CVTOSLV1,'02'x) <> '02'x then , /* Below OS/390 R1 */
Queue 'The MVS version is 'PRODNAME' - FMID 'FMIDNUM'.'
Else do
PRODNAM2 = Storage(D2x(ECVT+496),16) /* point to product name*/
PRODNAM2 = Strip(PRODNAM2,'T') /* del trailing blanks */
VER = Storage(D2x(ECVT+512),2) /* point to version */
REL = Storage(D2x(ECVT+514),2) /* point to release */
MOD = Storage(D2x(ECVT+516),2) /* point to mod level */
VRM = VER'.'REL'.'MOD
Queue 'The OS version is 'PRODNAM2 VRM' - FMID' ,
FMIDNUM' ('PRODNAME').'
End
If CVTVERID <> ' ' then ,
Queue 'The "user" system software version is' Strip(CVTVERID,'T')'.'
Queue 'The primary job entry subsystem is 'JESPJESN'.'
Queue 'The 'JESPJESN 'level is 'JESLEV'.' ,
'The 'JESPJESN 'node name is 'JESNODE'.'
If SECNAM <> 'RACF' | RACFVRM < '2608' then do
Queue 'The security software is 'SECNAM'.'
If SECNAM = 'ACF2' then do
Queue 'The ACF2 level is' ACCPIDS'.'
Queue ' There are 'ACF2DNUM' ACF2 data sets in use:'
Do ADSNS = 1 to ACF2DNUM
ADSOFF = ACF2DSNS + 24 + (ADSNS-1)*64
ACF2TYPE = Storage(D2x(ADSOFF) , 8)
ACF2DSN = Storage(D2x(ADSOFF + 16),44)
Queue ' ' ACF2TYPE '-' ACF2DSN
End
End /* if secname = 'ACF2' */
If Bitand(CVTOSLV6,'40'x) = '40'x then nop /* z/OS 2.2 and above */
Else Queue ' The RACF level is 'RACFLEV'.' /*dont show racflev*/
If SECNAM = 'Top Secret' then ,
Queue ' The TSS Security File data set is' RCVTDSN'.'
If SECNAM = 'RACF' then ,
Queue ' The RACF primary data set is' RCVTDSN'.'
End
Else do
/* RACF system */
RCVTDSDT = C2d(Storage(D2x(RCVT + 224),4)) /* point to RACFDSDT*/
DSDTNUM = C2d(Storage(D2x(RCVTDSDT+4),4)) /* num RACF dsns */
DSDTPRIM = Storage(D2x(RCVTDSDT+177),44) /* point to prim ds */
DSDTPRIM = Strip(DSDTPRIM,'T') /* del trail blanks */
DSDTBACK = Storage(D2x(RCVTDSDT+353),44) /* point to back ds */
DSDTBACK = Strip(DSDTBACK,'T') /* del trail blanks */
Queue 'The security software is' Word(PRODNAM2,1) ,
'Security Server (RACF).'
Queue 'The RACF level is' PRODNAM2 VRM || '.'
End
Else do
Queue 'The security software is' Word(PRODNAM2,1) ,
'Security Server (RACF).' ,
'The FMID is HRF' || RACFVRM || '.'
End
If DSDTNUM = 1 then do
Queue ' The RACF primary data set is' DSDTPRIM'.'
Queue ' The RACF backup data set is' DSDTBACK'.'
End
Else do
Queue ' RACF is using a split database. There are' DSDTNUM ,
'pairs of RACF data sets:'
RDTOFF = 0 /* init cur offset to 0 */
DSDTENTY_SIZE = 352 /* dsdtenty size */
Do RDSNS = 1 to DSDTNUM
DSDTPRIM = Storage(D2x(RCVTDSDT+177+RDTOFF),44) /* prim dsn */
DSDTPRIM = Strip(DSDTPRIM,'T') /* del blnks*/
DSDTBACK = Storage(D2x(RCVTDSDT+353+RDTOFF),44) /* bkup dsn */
DSDTBACK = Strip(DSDTBACK,'T') /* del blnks*/
RDTOFF = RDTOFF + DSDTENTY_SIZE /* next tbl entry */
Queue ' Primary #'RDSNS' - ' DSDTPRIM
Queue ' Backup #'RDSNS' - ' DSDTBACK
End /* do RDSNS = 1 to DSDTNUM */
End
End /* else do */
Queue 'The' DFPRD 'level is' DFLEV'.'
If DFPRD = 'DFSMS' then do
Queue ' The SMS parmlib member is IGDSMS'igdsms'.'
Queue ' The SMS ACDS data set name is' SMSACDS'.'
Queue ' The SMS COMMDS data set name is' SMSCMDS'.'
End
Queue 'The TSO level is 'TSOLEV'.'
If SYSISPF = 'ACTIVE' then do /* is ISPF active? */
Address ISPEXEC "VGET ZISPFOS" /* yes, is it OS?390? */
If RC = 0 then do /* yes, get OS/390 var */
ISPFLEV = Strip(Substr(ZISPFOS,10,15)) /* only need version */
Address ISPEXEC "VGET ZENVIR" /* ispf internal rel var*/
ISPFLEVI = Substr(ZENVIR,1,8) /* internal ISPF release*/
Queue 'The ISPF level is 'ISPFLEV' ('ISPFLEVI').'
End /* if RC */
Else do /* not OS/390 - use old variables */
Address ISPEXEC "VGET ZPDFREL" /* get pdf release info */
ISPFLEV = Substr(ZENVIR,6,3) /* ISPF level */
PDFLEV = Substr(ZPDFREL,5,3) /* PDF level */
Queue 'The ISPF level is 'ISPFLEV'. The PDF level is' PDFLEV'.'
End /* else do */
End /* if SYSISPF */
If VTAM_ACTIVE = 'YES' then do
Queue 'The VTAM level is 'VTAMLEV'.'
Queue ' The NETID is' ATCNETID'. The SSCPNAME is' ATCNQNAM'.'
End /* if VTAM_ACTIVE = YES */
Else Queue 'The VTAM level is not available - VTAM is not active.'
If TCP_ACTIVE = 'YES' then do
Queue 'The TCP/IP stack is active. ',
'There are 'TCPANUM' active TSEBs out of 'TSEBNUM'.'
Queue ' SI Proc Vers ASID ( dec) Status'
Queue ' -- -------- ---- ---- ------ ------'
Do LSI = 1 to TCPANUM
Queue ' 'Right(TCPNUM.LSI,2)' 'TCPNAME.LSI' 'TCPVER.LSI' ',
TCPASID.LSI' 'TCPST.LSI
End
End /* if TCP_ACTIVE = YES */
Else Queue 'The TCP level is not available - TCP is not active.'
Return
STOR: /* Storage information sub-routine */

Queue ' '
CVTRLSTG = C2d(Storage(D2x(CVT + 856),4)) /* point to store at IPL*/
CVTRLSTG = CVTRLSTG/1024 /* convert to Megabytes */
If zARCH <> 2 then do /* not valid in 64-bit */
CVTEORM = C2d(Storage(D2x(CVT + 312),4)) /* potential real high */
CVTEORM = (CVTEORM+1)/1024/1024 /* convert to Megabytes */
ESTOR = C2d(Storage(D2x(RCE + 160),4)) /* point to ESTOR frames*/
ESTOR = ESTOR*4/1024 /* convert to Megabytes */
End
/**********************************************************/
/* At z/OS 2.1 CVTRLSTG was not always correct. The code */
/* below gets the value from the RSM Internal Table */
/* field 'RITTOTALONLINESTORAGEATIPL'. */
/* The RIT is documented in the MVS Data Areas manual */
/* - This was a bug fixed by APAR OA48094 */
/**********************************************************/
/*
CVTPVTP = C2d(Storage(D2x(CVT+356),4)) /* point page vect tbl */
PVTRIT = C2x(Storage(D2x(CVTPVTP+4),4)) /* RSM internal tbl OCO */
RITOLSTG = X2d(C2x(Storage(D2x(X2d(PVTRIT)+X2d(128)),8)))
RITOLSTG = RITOLSTG/1024/1024 /* convert to Megabytes */
CVTRLSTG = RITOLSTG /* change the name for code below */
End
*/
ECVTEORM = C2d(Storage(d2x(ECVT+600),8)) /* potential real high */
RECONFIG = (ECVTEORM-CVTRLSTG*1024*1024+1)/(1024*1024) /* amt of */
/* reconfigurable stor */
End
RCECADSUsed = C2d(Storage(D2x(RCE + 572),2)) /* CADS current use */
RCECADSHW = C2d(Storage(D2x(RCE + 574),2)) /* CADS high water */
End
Call STORAGE_GDA_LDA
SCCBSAI = C2d(Storage(D2x(SCCB + 10),1)) /* real stor incr. in M */
If SCCBSAI = 0 then do /* If 0, use SCCBSAIX */
SCCBSAIX = C2d(Storage(D2x(SCCB + 100),4)) /* real stor incr in M*/
SCCBSAI = SCCBSAIX /* using SCCBSAI later */
End
SCCBSAR = C2d(Storage(D2x(SCCB + 8),2)) /* # of. incr installed */
End
If zARCH <> 2 then do /* not valid in 64-bit */
Queue 'The real storage size at IPL time was 'Format(CVTRLSTG,,0)'M.'
Queue 'The potential real storage size is' ,
Format(CVTEORM,,0)'M.'
If ESTOR > 0 then
Queue 'The expanded storage size is 'ESTOR'M.'
Else
Queue 'The system has no expanded storage.'
End /* If zARCH <> 2 */
Else Queue 'The real storage online at IPL time' ,
'was 'Format(CVTRLSTG,,0)'M.'
If Bitand(CVTOSLV2,'01'x) = '01'x then , /* OS/390 R10 and above */
If SCCBSAI <> 0 then ,
Queue 'The real storage increment size is 'SCCBSAI'M with' ,
SCCBSAR 'increments installed.'
Queue 'The potential real storage size is' ,
(ECVTEORM+1)/(1024*1024)'M.'
Queue 'The reconfigurable storage size is 'reconfig'MB.'
End
Queue 'The private area size <16M is 'GDAPVTSZ'K.'
Queue 'The private area size >16M is 'GDAEPVTS'M.'
Queue 'The CSA size <16M is 'GDACSASZ'K.'
Queue 'The CSA size >16M is 'GDAECSAS'K.'
Queue 'The SQA size <16M is 'GDASQASZ'K.'
Queue 'The SQA size >16M is 'GDAESQAS'K.'
Queue 'The maximum V=R region size is 'GDAVRSZ'K.'
Queue 'The default V=R region size is 'GDAVREGS'K.'
Queue 'The maximum V=V region size is 'LDASIZEA'K.'
Queue 'The current number of CADS (MAXCADs)' ,
'in use is 'RCECADSUsed'.'
Queue 'The maximum number of CADS (MAXCADs)' ,
'used since IPL is 'RCECADSHW'.'
End
Return
CPU: /* CPU information sub-routine */

Queue ' '
If Bitand(CVTOSLV3,'01'x) = '01'x then , /* z/OS 1.6 & above >16 CPs*/
NUMCPU = C2d(Storage(D2x(CSD + 212),4)) /* point to # of CPUS */
Else,
NUMCPU = C2d(Storage(D2x(CSD + 10),2)) /* point to # of CPUS */
SCCBNCPS = C2d(Storage(d2x(SCCB + 16),2)) /* Max No. of CPUs */
/* */
Queue 'The CPU model number is 'MODEL'.'
Queue 'The number of online CPUs is 'NUMCPU'.' ,
'The maximum number of CPUs is 'SCCBNCPS'.'
If Bitand(CVTOSLV3,'20'x) = '20'x & , /* z/OS 1.1 and above */
Bitand(CVTOSLV3,'01'x) <> '01'x then do /* but below z/OS 1.6 */
CSDICPUS = C2d(Storage(D2x(CSD+161),1)) /* CPUs online @ IPL */
Queue ' The number of CPUs online at IPL time was 'CSDICPUS'.'
End
CSDICPUS = C2d(Storage(D2x(CSD+161),1)) /* CPUs online @ IPL */
CSDIIFAS = C2d(Storage(D2x(CSD+162),1)) /* zAAPs online @ IPL */
Queue ' The number of GPs online at IPL time was 'CSDICPUS'.'
If CSDIIFAS <> 0 then ,
Queue ' The number of zAAPs online at IPL time was 'CSDIIFAS'.'
If Bitand(CVTOSLV4,'02'x) = '02'x then do /* zIIP (SUP) support */
CSDISUPS = C2d(Storage(D2x(CSD+163),1)) /* zIIPs online @ IPL */
If CSDISUPS <> 0 then ,
Queue ' The number of zIIPs online at IPL time was 'CSDISUPS'.'
End
End
/* */
CPNUM = 0
FOUNDCPUS = 0
FOUNDZAPS = 0
FOUNDZIPS = 0
Do until FOUNDCPUS = NUMCPU
PCCA = C2d(Storage(D2x(PCCAVT + CPNUM*4),4)) /* point to PCCA */
If PCCA <> 0 then do
CPUVER = Storage(D2x(PCCA + 4),2) /* point to VERSION */
CPUID = Storage(D2x(PCCA + 6),10) /* point to CPUID */
IDSHORT = Substr(CPUID,2,5)
PCCAATTR = Storage(D2x(PCCA + 376),1) /* attribute byte */
PCCARCFF = Storage(D2x(PCCA + 379),1) /* reconfig flag */
CP_TYP = '' /* init to null for now */
If Bitand(PCCAATTR,'01'x) = '01'x then do /* check PCCAIFA */
CP_TYP = '(zAAP)' /* zAAP / IFA CP */
FOUNDZAPS = FOUNDZAPS + 1
End
If Bitand(PCCAATTR,'04'x) = '04'x then do /* check PCCAzIIP */
CP_TYP = '(zIIP)' /* zIIP processor */
FOUNDZIPS = FOUNDZIPS + 1
End
If Bitand(PCCARCFF,'80'x) = '80'x then , /* check PCCACWLM */
CP_TYP = '(WLM)' /* WLM controlled CP */
CPNUM_M = D2x(CPNUM) /* display in hex */
If Bitand(CVTOSLV3,'01'x) = '01'x then , /* z/OS 1.6 & above */
CPNUM_M = Right(CPNUM_M,2,'0') /* display as 2 digits*/
Queue 'The CPU serial number for CPU 'CPNUM_M' is ' || ,
CPUID' ('IDSHORT'), version code' CPUVER'.' CP_TYP
FOUNDCPUS = FOUNDCPUS + 1
End
CPNUM = CPNUM + 1
End /* do until */
/**************************************************/
/* SUs/SEC and MIPS calculations */
/* SYS1.NUCLEUS(IEAVNP10) CSECT IRARMCPU */
/**************************************************/
RMCT = C2d(Storage(D2x(CVT+604),4)) /* point to RMCT */
SU = C2d(Storage(D2x(RMCT+64),4)) /* CPU Rate Adjustment */
SUSEC = Format((16000000/SU),7,2) /* SUs per second */
MIPSCP = NUMCPU-FOUNDZAPS-FOUNDZIPS /* Don't include special*/
/* processors for MIPs */
MIPS = Format((SUSEC/48.5) * MIPSCP,6,2) /* SRM MIPS calculation */
/* (48.5) borrowed from */
/* Thierry Falissard */
Queue 'The service units per second per online CPU is' Strip(SUSEC)'.'
Queue 'The approximate total MIPS (SUs/SEC / 48.5 * # general CPUs)' ,
'is' Strip(MIPS)'.'
/*
RMCTCCT = C2d(Storage(D2x(RMCT+4),4)) /* cpu mgmt control tbl */
CCVUTILP = C2d(Storage(D2x(RMCTCCT+102),2)) /* CPU Utilization */
Queue 'The approximate CPU utilization is' CCVUTILP'%.'
*/
/* w/APAR OW55509 */
RCT = C2d(Storage(D2x(RMCT+228),4)) /* Resource Control Tbl */
RCTLACS = C2d(Storage(D2x(RCT+196),4)) /* 4 hr MSU average */
RCTIMGWU = C2d(Storage(D2x(RCT+28),4)) /* Image defined MSUs */
RCTCECWU = C2d(Storage(D2x(RCT+32),4)) /* CEC MSU Capacity */
If RCTCECWU <> 0 then do
Queue 'The MSU capacity for this CEC is' RCTCECWU'.'
Queue 'The defined MSU capacity for this LPAR is' RCTIMGWU'.'
End
If RCTLACS <> 0 then do
Queue 'The 4 hour MSU average usage is' RCTLACS'.'
If RCTLACS >= RCTIMGWU & RCTIMGWU <> RCTCECWU then ,
Queue ' ** This LPAR is currently being "soft capped". **'
End
End
/* */
IEAVESVT = C2d(Storage(D2x(CVT + 868),4)) /* supv. vect tbl IHASVT*/
SVTAFFB = Storage(D2x(IEAVESVT + 12),1) /* aff-dispatch byte */
If Bitand(SVTAFFB,'80'x) = '80'x then ,
Queue 'The HiperDispatch feature is active on this LPAR.'
Else Queue 'The HiperDispatch feature is not active on this LPAR.'
CPCRPERC = C2d(Storage(D2x(IEAVESVT+1008),4)) /* CPCR Percent */
If CPCRPERC <> 0 then
Queue 'The CP Credits feature is active on this CPC/LPAR' ,
'at' CPCRPERC'%.'
End
/**************************************************/
/* Central Processing Complex Node Descriptor */
/**************************************************/
CVTHID = C2d(Storage(D2x(CVT + 1068),4)) /* point to SHID */
CPCND_FLAGS = Storage(D2x(CVTHID+22),1) /* pnt to CPCND FLAGS */
If CPCND_FLAGS <> 0 then do /* Is there a CPC? */
CPCND_VALID = Bitand(CPCND_FLAGS,'E0'x) /* Valid flags */
CPCND_INVALID = Bitand('40'x) /* Invalid flag */
If CPCND_VALID <> CPCND_INVALID then do /* Is it valid? */
CPCND_TYPE = Storage(D2x(CVTHID+26),6) /* Type */
CPCND_MODEL = Storage(D2x(CVTHID+32),3) /* Model */
CPCND_MAN = Storage(D2x(CVTHID+35),3) /* Manufacturer */
CPCND_PLANT = Storage(D2x(CVTHID+38),2) /* Plant of manufact. */
CPCND_SEQNO = Storage(D2x(CVTHID+40),12) /* Sequence number */
CPC_ID = C2x(Storage(D2x(CVTHID+55),1)) /* CPC ID */
Queue ' '
/* Queue 'Central Processing Complex (CPC) Node Descriptor:' */
Queue 'Central Processing Complex (CPC) Information:'
Queue ' CPC ND =',
CPCND_TYPE'.'CPCND_MODEL'.'CPCND_MAN'.'CPCND_PLANT'.'CPCND_SEQNO
If Bitand(CVTOSLV3,'10'x) = '10'x then do /*z/OS 1.2 & above*/
Call GET_CPCSI /* Get CPC SI (STSI) information sub-routine */
Queue ' CPC SI =' CPCSI_TYPE'.'CPCSI_MODEL'.' || ,
CPCSI_MAN'.'CPCSI_PLANT'.'CPCSI_CPUID
Queue ' Model:' CPCSI_MODELID
Queue ' CPC ID =' CPC_ID
Queue ' Type('CPCND_TYPE') Model('CPCND_MODEL')',
'Manufacturer('CPCND_MAN') Plant('CPCND_PLANT')',
'Seq Num('CPCND_SEQNO')'
RMCTX1M = Storage(D2x(RMCT+500),4) /* Microcode addr */
/* in RMCTX1 */
If RMCTX1M <> '7FFFF000'x then do /* skip VM/FLEX/ES*/
RMCTX1M = C2d(RMCTX1M) /* change to dec. */
MCL = Storage(D2x(RMCTX1M + 40),8) /* Microcode lvl */
MCLDRV = Substr(MCL,1,4) /* Driver only.. */
If Datatype(MCLDRV,'Number') = 1 then , /* if all numeric */
MCLDRV = Format(MCLDRV) /* rmv leading 0s */
Queue ' The Microcode level of this CPC is' MCL || ,
' (Driver' MCLDRV').'
End /* If RMCTX1M <> '7FFFF000'x */
End /* if CPCND_VALID <> CPCND_INVALID */
Else do
Call GET_CPCSI /* Get CPC SI (STSI) information sub-routine */
Queue ' '
Queue 'Central Processing Complex (CPC) Information:'
Queue ' CPC SI =' CPCSI_TYPE'.'CPCSI_MODEL'.' || ,
CPCSI_MAN'.'CPCSI_PLANT'.'CPCSI_CPUID
Queue ' Model:' CPCSI_MODELID
End /* if Bitand(CVTOSLV3,'10'x) = '10'x */
End /* else do */
End /* if CPCND_FLAGS <>0 */
End
Return
IPA: /* IPA information sub-routine */

Queue ' '
/*********************************************************************/
/* IPL parms from the IPA */
/*********************************************************************/
IPAICTOD = Storage(D2x(ECVTIPA + 8),8) /* point to IPL TOD */
IPALPARM = Storage(D2x(ECVTIPA + 16),8) /* point to LOAD PARM */
IPALPDSN = Storage(D2x(ECVTIPA + 48),44) /* load parm dsn name */
IPALPDDV = Storage(D2x(ECVTIPA + 92),4) /* load parm dev number */
IPAHWNAM = Storage(D2x(ECVTIPA + 24),8) /* point to HWNAME */
IPAHWNAM = Strip(IPAHWNAM,'T') /* del trailing blanks */
IPALPNAM = Storage(D2x(ECVTIPA + 32),8) /* point to LPARNAME */
IPALPNAM = Strip(IPALPNAM,'T') /* del trailing blanks */
IPAVMNAM = Storage(D2x(ECVTIPA + 40),8) /* point to VMUSERID */
/**************************/
/* PARMS in LOADxx */
/**************************/
IPANUCID = Storage(D2x(ECVTIPA + 23),1) /* NUCLEUS ID */
IPAIODF = Storage(D2x(ECVTIPA + 96),63) /* IODF card image */
IPASPARM = Storage(D2x(ECVTIPA + 160),63) /* SYSPARM card image */
/*IPASCAT= Storage(D2x(ECVTIPA + 224),63)*//* SYSCAT card image */
IPASYM = Storage(D2x(ECVTIPA + 288),63) /* IEASYM card image */
IPAPLEX = Storage(D2x(ECVTIPA + 352),63) /* SYSPLEX card image */
IPAPLNUMX = Storage(D2x(ECVTIPA + 2134),2) /* number of parmlibs */
IPAPLNUM = IPAPLNUMX
End
Else , /* OS/390 R10 and above */
IPAPLNUM = Storage(D2x(ECVTIPA + 2148),2) /* number of parmlibs */
IPAPLNUM = C2d(IPAPLNUM) /* convert to decimal */
POFF = 0
Do P = 1 to IPAPLNUM
IPAPLIB.P = Storage(D2x(ECVTIPA+416+POFF),63) /* PARMLIB cards */
IPAPLFLG.P = Storage(D2x(ECVTIPA+479+POFF),1) /* flag bits */
If Bitand(IPAPLFLG.P,'20'x) = '20'x then , /* volser from cat? */
IPAPLIB.P = Overlay(' ',IPAPLIB.P,46) /* no, clear it */
POFF = POFF + 64
End
IPANLID = Storage(D2x(ECVTIPA + 2144),2) /* NUCLSTxx member used */
IPANUCW = Storage(D2x(ECVTIPA + 2146),1) /* load wait state char */
IPAICTOD = C2x(IPAICTOD) /* make "readable" for REXXTOD call */
Call REXXTOD IPAICTOD /* convert TOD to YYYY.DDD HH:MM:SS.ttt */
TOD_RESY = Substr(RESULT,1,4) /* year portion from REXXTOD */
TOD_RESD = Substr(RESULT,6,3) /* day portion from REXXTOD */
TOD_REST = Substr(RESULT,10,8) /* time portion from REXXTOD */
Call RDATE TOD_RESY TOD_RESD /* call RDATE- format for ISO/USA/EUR */
MMIPA = Substr(RESULT,1,2) /* MM from MM/DD/YYYY */
DDIPA = Substr(RESULT,4,2) /* DD from MM/DD/YYYY */
YYYYIPA = Substr(RESULT,7,4) /* YYYY from MM/DD/YYYY */
IPAIDATE = Substr(RESULT,1,10) /* date as MM/DD/YYYY */
IPAIDATE = DDIPA'/'MMIPA'/'YYYYIPA /* date as DD/MM/YYYY */
IPAIDATE = YYYYIPA'-'MMIPA'-'DDIPA /* date as YYYY-MM-DD */
Queue 'Initialization information from the IPA:'
Queue ' IPL TIME (GMT):' IPAIDATE ,
'('TOD_RESY'.'TOD_RESD') at' TOD_REST
Queue ' IPLPARM =' IPALPARM '(merged)'
Queue ' IPL load parameter data set name: 'IPALPDSN
Queue ' IPL load parameter data set device address: 'IPALPDDV
Queue ' HWNAME='IPAHWNAM ' LPARNAME='IPALPNAM ,
' VMUSERID='IPAVMNAM
Queue ' ' /* add blank line for readability */
Queue ' LOADxx parameters from the IPA' ,
'(LOAD' || Substr(IPALPARM,5,2) || '):'
Queue ' *---+----1----+----2----+----3----+----4' || ,
'----+----5----+----6----+----7--'
If Bitand(CVTOSLV2,'01'x) = '01'x then do /* OS/390 R10 & above */
IPAARCHL = Storage(D2x(ECVTIPA + 2143),1) /* ARCHLVL (1 or 2) */
Queue ' ARCHLVL 'IPAARCHL
End
If IPASYM <> '' then queue ' IEASYM 'IPASYM
If IPAIODF <> '' then queue ' IODF 'IPAIODF
If IPANUCID <> '' then queue ' NUCLEUS 'IPANUCID
If IPANLID <> '' then queue ' NUCLST 'IPANLID' 'IPANUCW
Do P = 1 to IPAPLNUM
Queue ' PARMLIB 'IPAPLIB.P
End
If IPASCAT <> '' then queue ' SYSCAT 'IPASCAT
If IPASPARM <> '' then queue ' SYSPARM 'IPASPARM
If IPAPLEX <> '' then queue ' SYSPLEX 'IPAPLEX
/**************************/
/* PARMS in IEASYSxx */
/**************************/
Queue ' ' /* add blank line for readability */
Queue ' IEASYSxx parameters from the IPA: ',
' (Source)'
Call BUILD_IPAPDETB /* Build table for init parms */
TOTPRMS = 0 /* tot num of specified or defaulted parms */
Do I = 1 to IPAPDETB.0
Call EXTRACT_SYSPARMS IPAPDETB.I /* extract parms from the IPA */
End
/********************************************************************/
/* Uncommment a sample below to test IPA PAGE parm "split" code: */
/* PRMLINE.32 = 'SWAP SWAP=(SYS1.SWAP.TEST) IEASYSXX' */
/* PRMLINE.32 = 'NONVIO NONVIO=(SYS1.PAGE.TEST) IEASYSXX' */
/* PRMLINE.32 = 'NONVIO NONVIO=(SYS1.PAGE1,SYS1.PAGE2) IEASYSXX' */
/* PRMLINE.32 = 'NONVIO ' || , */
/* 'NONVIO=(SYS1.PAGE1,SYS1.PAGE2,SYS1.PAGE3,SYS1.PAGE4) IEASYSXX' */
/********************************************************************/
Call SORT_IPA /* sort IPA parms */
Call SPLIT_IPA_PAGE /* split page/swap dsn parms */
Do I = 1 to TOT_IPALINES /* add ipa parms */
If I = TOT_IPALINES then , /* to stack and */
IPALINE.I = Translate(IPALINE.I,' ',',') /* remove comma */
Queue IPALINE.I /* from last parm */
End
End
Return
SYMBOLS: /* System Symbols information sub-routine */

Queue ' '
/*********************************************************************/
/* Find System Symbols - ASASYMBP MACRO */
/* ECVT+X'128' = ECVTSYMT */
/* 2nd half word = # of symbols , after that each entry is 4 words */
/* 1st word = offset to symbol name */
/* 2nd word = length of symbol name */
/* 3rd word = offset to symbol value */
/* 4th word = length of symbol value */
/*********************************************************************/
ECVTSYMT = C2d(Storage(D2x(ECVT + 296),4)) /* point to ECVTSYMT */
NUMSYMBS = C2d(Storage(D2x(ECVTSYMT + 2),2)) /* number of symbols */
Queue 'Static System Symbol Values:'
Do I = 1 to NUMSYMBS
SOFF = I*16-16
NAMOFF = C2d(Storage(D2x(ECVTSYMT+4+SOFF),4)) /*offset to name */
NAMLEN = C2d(Storage(D2x(ECVTSYMT+8+SOFF),4)) /*length of name */
VALOFF = C2d(Storage(D2x(ECVTSYMT+12+SOFF),4)) /*offset to value*/
VALLEN = C2d(Storage(D2x(ECVTSYMT+16+SOFF),4)) /*length of value*/
SYMNAME = Storage(D2x(ECVTSYMT+4+NAMOFF),NAMLEN) /*symbol name */
If VALLEN = 0 then VALNAME = '' /* null value */
Else ,
VALNAME = Storage(D2x(ECVTSYMT+4+VALOFF),VALLEN) /* symbol value */
Queue ' ' Left(SYMNAME,10,' ') '=' VALNAME
End /* do NUMSYMBS */
End
Return
VMAP: /* Virtual Storage Map sub-routine */

Arg VMAPOPT
If option <> 'ALL' then,
Call STORAGE_GDA_LDA /* GDA/LDA stor routine */
SYSEND = X2d(LDASTRTS) + (LDASIZS*1024) - 1 /* end of system area */
SYSEND = D2x(SYSEND) /* display in hex */
If GDAVRSZ = 0 then do /* no v=r */
VRSTRT = 'N/A '
VREND = 'N/A '
VVSTRT = LDASTRTA /* start of v=v */
VVEND = X2d(LDASTRTA) + (LDASIZEA*1024) - 1 /* end of v=v */
VVEND = D2x(VVEND) /* display in hex */
End
Else do
VRSTRT = LDASTRTA /* start of v=r */
VREND = X2d(LDASTRTA) + (GDAVRSZ*1024) - 1 /* end of v=r */
VREND = D2X(VREND) /* display in hex */
VVSTRT = LDASTRTA /* start of v=v */
VVEND = X2d(LDASTRTA) + (LDASIZEA*1024) - 1 /* end of v=v */
VVEND = D2x(VVEND) /* display in hex */
End
GDACSA = C2d(Storage(D2x(CVTGDA + 108),4)) /* start of CSA addr */
GDACSAH = D2x(GDACSA) /* display in hex */
CSAEND = (GDACSASZ*1024) + GDACSA - 1 /* end of CSA */
CSAEND = D2x(CSAEND) /* display in hex */
CVTSMEXT = C2d(Storage(D2x(CVT +1196),4)) /* point to stg map ext.*/
CVTMLPAS = C2d(Storage(D2x(CVTSMEXT+ 8),4)) /* start of MLPA addr */
CVTMLPAS = D2x(CVTMLPAS) /* display in hex */
If CVTMLPAS <> 0 then do
CVTMLPAE = C2d(Storage(D2x(CVTSMEXT+12),4)) /* end of MLPA addr */
CVTMLPAE = D2x(CVTMLPAE) /* display in hex */
MLPASZ = X2d(CVTMLPAE) - X2d(CVTMLPAS) + 1 /* size of MLPA */
MLPASZ = MLPASZ/1024 /* convert to Kbytes */
End
Else do /* no MLPA */
CVTMLPAS = 'N/A '
CVTMLPAE = 'N/A '
MLPASZ = 0
End
CVTFLPAS = C2d(Storage(D2x(CVTSMEXT+16),4)) /* start of FLPA addr */
CVTFLPAS = D2x(CVTFLPAS) /* display in hex */
If CVTFLPAS <> 0 then do
CVTFLPAE = C2d(Storage(D2x(CVTSMEXT+20),4)) /* end of FLPA addr */
CVTFLPAE = D2x(CVTFLPAE) /* display in hex */
FLPASZ = X2d(CVTFLPAE) - X2d(CVTFLPAS) + 1 /* size of FLPA */
FLPASZ = FLPASZ/1024 /* convert to Kbytes */
End
Else do /* no FLPA */
CVTFLPAS = 'N/A '
CVTFLPAE = 'N/A '
FLPASZ = 0
End
CVTPLPAS = C2d(Storage(D2x(CVTSMEXT+24),4)) /* start of PLPA addr */
CVTPLPAS = D2x(CVTPLPAS) /* display in hex */
CVTPLPAE = C2d(Storage(D2x(CVTSMEXT+28),4)) /* end of PLPA addr */
CVTPLPAE = D2x(CVTPLPAE) /* display in hex */
PLPASZ = X2d(CVTPLPAE) - X2d(CVTPLPAS) + 1 /* size of PLPA */
PLPASZ = PLPASZ/1024 /* convert to Kbytes */
GDASQA = C2d(Storage(D2x(CVTGDA + 144),4)) /* start of SQA addr */
GDASQAH = D2x(GDASQA) /* display in hex */
SQAEND = (GDASQASZ*1024) + GDASQA - 1 /* end of SQA */
SQAEND = D2x(SQAEND) /* display in hex */
CVTRWNS = C2d(Storage(D2x(CVTSMEXT+32),4)) /* start of R/W nucleus */
CVTRWNS = D2x(CVTRWNS) /* display in hex */
CVTRWNE = C2d(Storage(D2x(CVTSMEXT+36),4)) /* end of R/W nucleus */
CVTRWNE = D2x(CVTRWNE) /* display in hex */
RWNUCSZ = X2d(CVTRWNE) - X2d(CVTRWNS) + 1 /* size of R/W nucleus */
RWNUCSZ = Format(RWNUCSZ/1024,,0) /* convert to Kbytes */
CVTRONS = C2d(Storage(D2x(CVTSMEXT+40),4)) /* start of R/O nucleus */
CVTRONS = D2x(CVTRONS) /* display in hex */
CVTRONE = C2d(Storage(D2x(CVTSMEXT+44),4)) /* end of R/O nucleus */
CVTRONE = D2x(CVTRONE) /* display in hex */
RONUCSZ = X2d(CVTRONE) - X2d(CVTRONS) + 1 /* size of R/O nucleus */
RONUCSZ = Format(RONUCSZ/1024,,0) /* convert to Kbytes */
RONUCSZB = X2d('FFFFFF') - X2d(CVTRONS) + 1 /* size of R/O nuc <16M */
RONUCSZB = Format(RONUCSZB/1024,,0) /* convert to Kbytes */
RONUCSZA = X2d(CVTRONE) - X2d('1000000') + 1 /* size of R/O nuc >16M */
RONUCSZA = Format(RONUCSZA/1024,,0) /* convert to Kbytes */
CVTERWNS = C2d(Storage(D2x(CVTSMEXT+48),4)) /* start of E-R/W nuc */
CVTERWNS = D2x(CVTERWNS) /* display in hex */
CVTERWNE = C2d(Storage(D2x(CVTSMEXT+52),4)) /* end of E-R/W nuc */
CVTERWNE = D2x(CVTERWNE) /* display in hex */
ERWNUCSZ = X2d(CVTERWNE) - X2d(CVTERWNS) + 1 /* size of E-R/W nuc */
ERWNUCSZ = ERWNUCSZ/1024 /* convert to Kbytes */
GDAESQA = C2d(Storage(D2x(CVTGDA + 152),4)) /* start of ESQA addr */
GDAESQAH = D2x(GDAESQA) /* display in hex */
ESQAEND = (GDAESQAS*1024) + GDAESQA - 1 /* end of ESQA */
ESQAEND = D2x(ESQAEND) /* display in hex */
CVTEPLPS = C2d(Storage(D2x(CVTSMEXT+56),4)) /* start of EPLPA addr */
CVTEPLPS = D2x(CVTEPLPS) /* display in hex */
CVTEPLPE = C2d(Storage(D2x(CVTSMEXT+60),4)) /* end of EPLPA addr */
CVTEPLPE = D2x(CVTEPLPE) /* display in hex */
EPLPASZ = X2d(CVTEPLPE) - X2d(CVTEPLPS) + 1 /* size of EPLPA */
EPLPASZ = EPLPASZ/1024 /* convert to Kbytes */
CVTEFLPS = C2d(Storage(D2x(CVTSMEXT+64),4)) /* start of EFLPA addr */
CVTEFLPS = D2x(CVTEFLPS) /* display in hex */
If CVTEFLPS <> 0 then do
CVTEFLPE = C2d(Storage(D2x(CVTSMEXT+68),4)) /* end of EFLPA addr */
CVTEFLPE = D2x(CVTEFLPE) /* display in hex */
EFLPASZ = X2d(CVTEFLPE) - X2d(CVTEFLPS) + 1 /* size of EFLPA */
EFLPASZ = EFLPASZ/1024 /* convert to Kbytes */
End
Else do /* no EFLPA */
CVTEFLPS = 'N/A '
CVTEFLPE = 'N/A '
EFLPASZ = 0
End
CVTEMLPS = C2d(Storage(D2x(CVTSMEXT+72),4)) /* start of EMLPA addr */
CVTEMLPS = D2x(CVTEMLPS) /* display in hex */
If CVTEMLPS <> 0 then do
CVTEMLPE = C2d(Storage(D2x(CVTSMEXT+76),4)) /* end of EMLPA addr */
CVTEMLPE = D2x(CVTEMLPE) /* display in hex */
EMLPASZ = X2d(CVTEMLPE) - X2d(CVTEMLPS) + 1 /* size of EMLPA */
EMLPASZ = EMLPASZ/1024 /* convert to Kbytes */
End
Else do /* no EMLPA */
CVTEMLPS = 'N/A '
CVTEMLPE = 'N/A '
EMLPASZ = 0
End
GDAECSA = C2d(Storage(D2x(CVTGDA + 124),4)) /* start of ECSA addr */
GDAECSAH = D2x(GDAECSA) /* display in hex */
ECSAEND = (GDAECSAS*1024) + GDAECSA - 1 /* end of ECSA */
ECSAEND = D2x(ECSAEND) /* display in hex */
GDAEPVT = C2d(Storage(D2x(CVTGDA + 168),4)) /* start of EPVT addr */
GDAEPVTH = D2x(GDAEPVT) /* display in hex */
EPVTEND = (GDAEPVTS*1024*1024) + GDAEPVT - 1 /* end of EPVT */
EPVTEND = D2x(EPVTEND) /* display in hex */
If VMAPOPT <> 'NODISP' then do /* no display of vmap desired */
Queue ' '
Queue 'Virtual Storage Map:'
Queue ' '
If VMAP = 'HIGHFIRST' then do
Queue ' Storage Area Start End Size' ,
' Used Conv HWM'
Else ,
' Used Conv'
Queue ' '
Queue ' Ext. Private ' Right(GDAEPVTH,8,'0') ' ' ,
Right(EPVTEND,8,'0') Right(GDAEPVTS,8,' ')'M'
Queue ' Ext. CSA ' Right(GDAECSAH,8,'0') ' ' ,
Right(ECSAEND,8,'0') Right(GDAECSAS,8,' ')'K' ,
Right(GDA_ECSA_ALLOC,8,' ')'K ' ,
Right(GDAECSAHWM,7,' ')'K'
Else ,
Right(GDA_ECSA_ALLOC,8,' ')'K'
Queue ' Ext. MLPA ' Right(CVTEMLPS,8,'0') ' ' ,
Right(CVTEMLPE,8,'0') Right(EMLPASZ,8,' ')'K'
Queue ' Ext. FLPA ' Right(CVTEFLPS,8,'0') ' ' ,
Right(CVTEFLPE,8,'0') Right(EFLPASZ,8,' ')'K'
Queue ' Ext. PLPA ' Right(CVTEPLPS,8,'0') ' ' ,
Right(CVTEPLPE,8,'0') Right(EPLPASZ,8,' ')'K'
Queue ' Ext. SQA ' Right(GDAESQAH,8,'0') ' ' ,
Right(ESQAEND,8,'0') Right(GDAESQAS,8,' ')'K' ,
Right(GDA_ESQA_ALLOC,8,' ')'K' Right(GDA_ECSA_CONV,7,' ')'K',
Right(GDAESQAHWM,7,' ')'K'
Else ,
Right(GDA_ESQA_ALLOC,8,' ')'K' Right(GDA_ECSA_CONV,7,' ')'K'
Queue ' Ext. R/W Nucleus ' Right(CVTERWNS,8,'0') ' ' ,
Right(CVTERWNE,8,'0') Right(ERWNUCSZ,8,' ')'K'
Queue ' Ext. R/O Nucleus ' Right('1000000',8,'0') ' ' ,
Right(CVTRONE,8,'0') Right(RONUCSZA,8,' ')'K' ,
'(Total' RONUCSZ'K)'
Queue ' 16M line -----------------------------'
Queue ' R/O Nucleus ' Right(CVTRONS,8,'0') ' ' ,
Right('FFFFFF',8,'0') Right(RONUCSZB,8,' ')'K',
'(Spans 16M line)'
Queue ' R/W Nucleus ' Right(CVTRWNS,8,'0') ' ' ,
Right(CVTRWNE,8,'0') Right(RWNUCSZ,8,' ')'K'
Queue ' SQA ' Right(GDASQAH,8,'0') ' ' ,
Right(SQAEND,8,'0') Right(GDASQASZ,8,' ')'K' ,
Right(GDA_SQA_ALLOC,8,' ')'K' Right(GDA_CSA_CONV,7,' ')'K' ,
Right(GDASQAHWM,7,' ')'K'
Else ,
Right(GDA_SQA_ALLOC,8,' ')'K' Right(GDA_CSA_CONV,7,' ')'K'
Queue ' PLPA ' Right(CVTPLPAS,8,'0') ' ' ,
Right(CVTPLPAE,8,'0') Right(PLPASZ,8,' ')'K'
Queue ' FLPA ' Right(CVTFLPAS,8,'0') ' ' ,
Right(CVTFLPAE,8,'0') Right(FLPASZ,8,' ')'K'
Queue ' MLPA ' Right(CVTMLPAS,8,'0') ' ' ,
Right(CVTMLPAE,8,'0') Right(MLPASZ,8,' ')'K'
Queue ' CSA ' Right(GDACSAH,8,'0') ' ' ,
Right(CSAEND,8,'0') Right(GDACSASZ,8,' ')'K' ,
Right(GDA_CSA_ALLOC,8,' ')'K ' ,
Right(GDACSAHWM,7,' ')'K'
Else ,
Right(GDA_CSA_ALLOC,8,' ')'K'
Queue ' Private V=V ' Right(VVSTRT,8,'0') ' ' ,
Right(VVEND,8,'0') Right(LDASIZEA,8,' ')'K'
Queue ' Private V=R ' Right(VRSTRT,8,'0') ' ' ,
Right(VREND,8,'0') Right(GDAVRSZ,8,' ')'K'
Queue ' System ' Right(LDASTRTS,8,'0') ' ' ,
Right(SYSEND,8,'0') Right(LDASIZS,8,' ')'K'
If zARCH = 2 then ,
Queue ' PSA 00000000 00001FFF 8K'
Else ,
Queue ' PSA 00000000 00000FFF 4K'
End /* if VMAP = 'HIGHFIRST' */
Else do /* VMAP <> 'HIGHFIRST' */
' Used Conv HWM'
Else ,
' Used Conv'
Queue ' '
If zARCH = 2 then ,
Queue ' PSA 00000000 00001FFF 8K'
Else ,
Queue ' PSA 00000000 00000FFF 4K'
Queue ' System ' Right(LDASTRTS,8,'0') ' ' ,
Right(SYSEND,8,'0') Right(LDASIZS,8,' ')'K'
Queue ' Private V=R ' Right(VRSTRT,8,'0') ' ' ,
Right(VREND,8,'0') Right(GDAVRSZ,8,' ')'K'
Queue ' Private V=V ' Right(VVSTRT,8,'0') ' ' ,
Right(VVEND,8,'0') Right(LDASIZEA,8,' ')'K'
Right(GDA_CSA_ALLOC,8,' ')'K ' ,
Right(GDACSAHWM,7,' ')'K'
Else ,
Right(GDA_CSA_ALLOC,8,' ')'K'
Queue ' MLPA ' Right(CVTMLPAS,8,'0') ' ' ,
Right(CVTMLPAE,8,'0') Right(MLPASZ,8,' ')'K'
Queue ' FLPA ' Right(CVTFLPAS,8,'0') ' ' ,
Right(CVTFLPAE,8,'0') Right(FLPASZ,8,' ')'K'
Queue ' PLPA ' Right(CVTPLPAS,8,'0') ' ' ,
Right(CVTPLPAE,8,'0') Right(PLPASZ,8,' ')'K'
Right(GDA_SQA_ALLOC,8,' ')'K' Right(GDA_CSA_CONV,7,' ')'K' ,
Right(GDASQAHWM,7,' ')'K'
Else ,
Right(GDA_SQA_ALLOC,8,' ')'K' Right(GDA_CSA_CONV,7,' ')'K'
Queue ' R/W Nucleus ' Right(CVTRWNS,8,'0') ' ' ,
Right(CVTRWNE,8,'0') Right(RWNUCSZ,8,' ')'K'
Queue ' R/O Nucleus ' Right(CVTRONS,8,'0') ' ' ,
Right('FFFFFF',8,'0') Right(RONUCSZB,8,' ')'K',
'(Spans 16M line)'
Queue ' 16M line -----------------------------'
Queue ' Ext. R/O Nucleus ' Right('1000000',8,'0') ' ' ,
Right(CVTRONE,8,'0') Right(RONUCSZA,8,' ')'K' ,
'(Total' RONUCSZ'K)'
Queue ' Ext. R/W Nucleus ' Right(CVTERWNS,8,'0') ' ' ,
Right(CVTERWNE,8,'0') Right(ERWNUCSZ,8,' ')'K'
Right(GDA_ESQA_ALLOC,8,' ')'K' Right(GDA_ECSA_CONV,7,' ')'K',
Right(GDAESQAHWM,7,' ')'K'
Else ,
Right(GDA_ESQA_ALLOC,8,' ')'K' Right(GDA_ECSA_CONV,7,' ')'K'
Queue ' Ext. PLPA ' Right(CVTEPLPS,8,'0') ' ' ,
Right(CVTEPLPE,8,'0') Right(EPLPASZ,8,' ')'K'
Queue ' Ext. FLPA ' Right(CVTEFLPS,8,'0') ' ' ,
Right(CVTEFLPE,8,'0') Right(EFLPASZ,8,' ')'K'
Queue ' Ext. MLPA ' Right(CVTEMLPS,8,'0') ' ' ,
Right(CVTEMLPE,8,'0') Right(EMLPASZ,8,' ')'K'
Right(GDA_ECSA_ALLOC,8,' ')'K ' ,
Right(GDAECSAHWM,7,' ')'K'
Else ,
Right(GDA_ECSA_ALLOC,8,' ')'K'
Queue ' Ext. Private ' Right(GDAEPVTH,8,'0') ' ' ,
Right(EPVTEND,8,'0') Right(GDAEPVTS,8,' ')'M'
End /* else do (VMAP <> 'HIGHFIRST') */
If bitand(CVTOSLV3,'02'x) = '02'x then do /* z/OS 1.5 and above? */

/* Yes, get HVSHARE info from the RCE */
RCELVSHRSTRT = C2d(Storage(D2x(RCE + 544),8)) /* low virt addr */
/* for 64-bit shr */
RCELVSHRSTRT_D = C2x(Storage(D2x(RCE + 544),8)) /* make readable */
VSHRSTRT_D = Substr(RCELVSHRSTRT_D,1,8) , /* address range */
Substr(RCELVSHRSTRT_D,9,8) /* display */
RCELVHPRSTRT = C2d(Storage(D2x(RCE + 552),8)) /* low virt addr */
/* for 64-bit prv */
RCELVHPRSTRT_D = C2d(Storage(D2x(RCE + 552),8)) -1 /*make readable */
RCELVHPRSTRT_D = Right(D2x(RCELVHPRSTRT_D),16,'0') /* address */
VHPRSTRT_D = Substr(RCELVHPRSTRT_D,1,8) , /* range */
Substr(RCELVHPRSTRT_D,9,8) /* display */
TOTAL_VHSHR = RCELVHPRSTRT - RCELVSHRSTRT /* total shared */
TOTAL_VHSHR = TOTAL_VHSHR/1024/1024 /* change to MB */
TOTAL_VHSHR = FORMAT_MEMSIZE(TOTAL_VHSHR) /* format size */
RCELVSHRSTRT = RCELVSHRSTRT/1024/1024 /* change to MB */

RCELVSHRSTRT = FORMAT_MEMSIZE(RCELVSHRSTRT) /* format size */
RCELVHPRSTRT = RCELVHPRSTRT/1024/1024 /* change to MB */

RCELVHPRSTRT = FORMAT_MEMSIZE(RCELVHPRSTRT) /* format size */
RCELVSHRPAGES = C2d(Storage(D2x(RCE + 584),8)) /* shr pages */

RCELVSHRPAGES = (RCELVSHRPAGES*4)/1024 /* change to MB */
RCELVSHRPAGES = FORMAT_MEMSIZE(RCELVSHRPAGES) /* format size */
RCELVSHRGBYTES = C2d(Storage(D2x(RCE + 592),8)) /* shr bytes HWM */

RCELVSHRGBYTES = RCELVSHRGBYTES/1024/1024 /* change to MB */
RCELVSHRGBYTES = FORMAT_MEMSIZE(RCELVSHRGBYTES) /* format size */
Queue ' '

Queue ' 64-Bit Shared Virtual Storage (HVSHARE):'
Queue ' '
Queue ' Shared storage total:' TOTAL_VHSHR
Queue ' Shared storage range:' RCELVSHRSTRT'-'RCELVHPRSTRT ,
'('VSHRSTRT_D' - 'VHPRSTRT_D')'
Queue ' Shared storage allocated:' RCELVSHRPAGES
Queue ' Shared storage allocated HWM:' RCELVSHRGBYTES
End /* If bitand(CVTOSLV3,'02'x) = '02'x */
If bitand(CVTOSLV5,'08'x) = '08'x then do /* z/OS 1.10 and above */

/* Yes, get HVCOMMON info from the RCE */
RCEHVCommonStrt = C2d(Storage(D2x(RCE + 872),8)) /*low virt addr */
/*for 64-bit cmn*/
CommonStrt_D = C2x(Storage(D2x(RCE + 872),8)) /*make readable */
CommonStrt_D = Substr(CommonStrt_D,1,8) , /* address range*/
Substr(CommonStrt_D,9,8) /* display */
RCEHVCommonEnd = C2d(Storage(D2x(RCE + 880),8)) /*high virt addr*/

/*for 64-bit cmn*/
RCEHVCommonEnd = RCEHVCommonEnd + 1 /* Add 1 to addr*/
CommonEnd_D = C2x(Storage(D2x(RCE + 880),8)) /*make readable */
CommonEnd_D = Substr(CommonEnd_D,1,8) , /* address range*/
Substr(CommonEnd_D,9,8) /* display */
TOTAL_VHCOMN = RCEHVCommonEnd-RCEHVCommonStrt /* total common */

TOTAL_VHCOMN = TOTAL_VHCOMN/1024/1024 /* change to MB */
TOTAL_VHCOMN = FORMAT_MEMSIZE(TOTAL_VHCOMN) /* format size */
RCEHVCommonStrt = RCEHVCommonStrt/1024/1024 /* chg to MB */

RCEHVCommonStrt = FORMAT_MEMSIZE(RCEHVCommonStrt) /* format size */
RCEHVCommonEnd = RCEHVCommonEnd/1024/1024 /* chg to MB */

RCEHVCommonEnd = FORMAT_MEMSIZE(RCEHVCommonEnd) /* format size */
RCEHVCommonPAGES = C2d(Storage(D2x(RCE + 888),8)) /* comn pages */

RCEHVCommonPAGES = (RCEHVCommonPAGES*4)/1024 /* chg to MB */
RCEHVCommonPAGES = FORMAT_MEMSIZE(RCEHVCommonPAGES) /*format size*/
RCEHVCommonHWMBytes = C2d(Storage(D2x(RCE + 896),8)) /* comn HWM */
RCEHVCommonHWMBytes = RCEHVCommonHWMBytes/1024/1024 /*chg to MB */
RCEHVCommonHWMBytes = FORMAT_MEMSIZE(RCEHVCommonHWMBytes) /* fmt */
Queue ' '

Queue ' 64-Bit Common Virtual Storage (HVCOMMON):'
Queue ' '
Queue ' Common storage total:' TOTAL_VHCOMN
Queue ' Common storage range:' RCEHVCommonStrt'-'RCEHVCommonEnd ,
'('CommonStrt_D' - 'CommonEnd_D')'
Queue ' Common storage allocated:' RCEHVCommonPAGES
Queue ' Common storage allocated HWM:' RCEHVCommonHWMBytes
End /* If bitand(CVTOSLV5,'08'x) = '08'x */
If Bitand(CVTOSLV5,'10'x) = '10'x & , /* z/OS 1.9 and above & */
Bitand(CVTFLAG2,'01'x) = '01'x then do /* CVTEDAT on (z10 >)? */
LARGEMEM = 1 /* set LARGEMEM avail flg*/
RCEReconLFASize = C2d(Storage(D2x(RCE + 760),8)) /* recon lfarea */
RCENonReconLFASize = C2d(Storage(D2x(RCE + 768),8)) /* LFAREA */
/* Comment out or delete the next 2 lines of code if you want the */
/* large memory displays even if you specified or defaulted to */
/* LFAREA=0M (z/OS 1.9 & above) and have the hardware support. */
If RCEReconLFASize = 0 & RCENonReconLFASize = 0 then , /* both 0? */
LARGEMEM = 0
PL = 1 /* pageable1m + 2.1 & > */
/*****************/
/* 2G frame code */
/*****************/
RCE2GMemoryObjects = ,
C2d(Storage(D2x(RCE + 1256),8)) /* Number of 2G objects */
RCE2GNonReconLFASize = ,
C2d(Storage(D2x(RCE + 1272),8)) /* 2G frame area in 2G units */
RCE2GNonReconLFAUsed = ,
C2d(Storage(D2x(RCE + 1280),8)) /* used 2G frames */
RCE2GHWM = ,
C2d(Storage(D2x(RCE + 1288),4)) /* 2G used frames HWM */
If RCE2GNonReconLFASize <> 0 then LARGEMEM = 1 /* lfarea used */
End
Else PL = 0 /* no pageable1m */
End /* If Bitand(CVTOSLV5,'10'x) */
Else LARGEMEM = 0 /* < z/OS 1.9/no hw supt */
If LARGEMEM = 1 then do /* z/OS 1.10 & above */
RCELargeMemoryObjects = ,
C2d(Storage(D2x(RCE + 744),8)) /*tot large mem objs */
RCELargePagesBackedinReal = ,
C2d(Storage(D2x(RCE + 752),8)) /* tot lrg obj pages */
RCELFAvailGroups = ,
C2d(Storage(D2x(RCE + 796),4)) /* avial lrg frames */
RCEReconLFAUsed = ,
C2d(Storage(D2x(RCE + 776),8)) /* # recon 1M frames alloc */
RCENonReconLFAUsed = ,
C2d(Storage(D2x(RCE + 784),8)) /* # nonrecon 1M frames alloc */
LFASize = RCEReconLFASize + RCENonReconLFASize /* LFAREA size*/

LFA_Used = RCEReconLFAUsed + RCENonReconLFAUsed /* used LFAREA*/
LFA_Alloc1M = RCELargePagesBackedinReal /* 1M alloc */
LFA_Alloc4K = LFA_Used - LFA_Alloc1M /* 4K alloc */
If PL = 1 then do /* z/OS 2.1 / pageable1m support */

RCELargeUsed4K = ,
C2d(Storage(D2x(RCE + 1032),4)) /* 4K used for 1M req */
LFA_Alloc4K = RCELargeUsed4K /* chg var name for old code */
RceLargeAllocatedPL = ,
C2d(Storage(D2x(RCE + 1244),4)) /* # used pageable1m */
RceLargeUsedPLHWM = ,
C2d(Storage(D2x(RCE + 1252),4)) /* pageable1m HWM */
End
LFASize = FORMAT_MEMSIZE(LFASize) /* format size */

LFA_Avail = FORMAT_MEMSIZE(RCELFAvailGroups) /* format size */
LFA_Alloc1M = FORMAT_MEMSIZE(LFA_Alloc1M) /* format size */
LFA_Alloc4K = FORMAT_MEMSIZE(LFA_Alloc4K) /* format size */
If PL = 1 then do /* z/OS 2.1 + pageable1m support */

RceLargeAllocatedPL = FORMAT_MEMSIZE(RceLargeAllocatedPL)
RceLargeUsedPLHWM = FORMAT_MEMSIZE(RceLargeUsedPLHWM)
/*****************/
/* 2G frame code */
/*****************/
LFA2G_Size = FORMAT_MEMSIZE(RCE2GNonReconLFASize*2048)
LFA2G_Used = FORMAT_MEMSIZE(RCE2GNonReconLFAUsed*2048)
LFA2G_avail = ((RCE2GNonReconLFASize-RCE2GNonReconLFAUsed)*2048)
LFA2G_avail = FORMAT_MEMSIZE(LFA2G_avail)
LFA2G_Max = RCE2GHWM*2048
LFA2G_Max = FORMAT_MEMSIZE(LFA2G_Max)
End

RceLargeUsed1MHWM = ,
C2d(Storage(D2x(RCE + 804),4)) /*large pg HWM alloc behalf 1M */
RceLargeUsed4KHWM = ,
C2d(Storage(D2x(RCE + 808),4)) /*large pg HWM alloc behalf 4K */
LFA_Max1M = FORMAT_MEMSIZE(RceLargeUsed1MHWM) /* format size */
LFA_Max4K = FORMAT_MEMSIZE(RceLargeUsed4KHWM) /* format size */
End
Queue ' '

Queue ' 64-Bit Large Memory Virtual Storage (LFAREA):'
Queue ' '
Queue ' Large memory area (LFAREA) :' LFASize ',' LFA2G_Size
Queue ' Large memory storage available:' LFA_Avail ',' ,
LFA2G_avail
End
Else do
Queue ' Large memory area (LFAREA) :' LFASize
Queue ' Large memory storage available:' LFA_Avail
End
Queue ' Large memory storage allocated (1M):' LFA_Alloc1M
Queue ' Large memory storage allocated (4K):' LFA_Alloc4K
Queue ' Large memory storage allocated HWM (1M):' LFA_Max1M
Queue ' Large memory storage allocated HWM (4K):' LFA_Max4K
End
Queue ' Large memory storage allocated (PAGEABLE1M):' ,
RceLargeAllocatedPL
Queue ' Large memory storage allocated HWM (PAGEABLE1M):' ,
RceLargeUsedPLHWM
Queue ' Large memory storage allocated (2G):' LFA2G_Used ,
'/' RCE2GNonReconLFAUsed 'pages'
Queue ' Large memory storage allocated HWM (2G):' LFA2G_Max ,
'/' RCE2GHWM 'pages'
End
Queue ' Large memory objects allocated:' RCELargeMemoryObjects
If PL = 1 then , /* z/OS 2.1 / pageable1m support */
Queue ' Large memory objects allocated (2G):' RCE2GMemoryObjects
End
End /* If VMAPOPT <> 'NODISP' */
Return
PAGE: /* Page Data Sets information sub-routine */

Queue ' '
Queue 'Page Data Set Usage:'
Queue ' Type Full Slots Dev Volser Data Set Name'
ASMPART = C2d(Storage(D2x(ASMVT + 8),4)) /* Pnt to Pag Act Ref Tbl */
PARTSIZE = C2d(Storage(D2x(ASMPART+4),4)) /* Tot number of entries */
PARTDSNL = C2d(Storage(D2x(ASMPART+24),4)) /* Point to 1st pg dsn */
PARTENTS = ASMPART+80 /* Point to 1st parte */
Do I = 1 to PARTSIZE
If I > 1 then do
PARTENTS = PARTENTS + 96
PARTDSNL = PARTDSNL + 44
End
CHKINUSE = Storage(D2x(PARTENTS+9),1) /* in use flag */
If Bitand(CHKINUSE,'80'x) = '80'x then iterate /* not in use */
PGDSN = Storage(D2x(PARTDSNL),44) /* page data set name */
PGDSN = Strip(PGDSN,'T') /* remove trailing blanks */
PARETYPE = Storage(D2x(PARTENTS+8),1) /* type flag */
Select
When Bitand(PARETYPE,'80'x) = '80'x then PGTYPE = ' PLPA '
When Bitand(PARETYPE,'40'x) = '40'x then PGTYPE = ' COMMON '
When Bitand(PARETYPE,'20'x) = '20'x then PGTYPE = ' DUPLEX '
When Bitand(PARETYPE,'10'x) = '10'x then PGTYPE = ' LOCAL '
Otherwise PGTYPE = '??????'
End /* Select */
If PGTYPE = ' LOCAL ' then do
PAREFLG1 = Storage(D2x(PARTENTS+9),1) /* PARTE flags */
If Bitand(PAREFLG1,'10'x) = '10'x then PGTYPE = ' LOCAL NV'
End
PAREUCBP = C2d(Storage(D2x(PARTENTS+44),4)) /* point to UCB */
PGUCB = C2x(Storage(D2x(PAREUCBP+4),2)) /* UCB address */
PGVOL = Storage(D2x(PAREUCBP+28),6) /* UCB volser */
PARESZSL = C2d(Storage(D2x(PARTENTS+16),4)) /* total slots */
PARESZSL = Right(PARESZSL,9,' ') /* ensure 9 digits */
PARESLTA = C2d(Storage(D2x(PARTENTS+20),4)) /* avail. slots */
PGFULL = ((PARESZSL-PARESLTA) / PARESZSL) * 100 /* percent full */
PGFULL = Format(PGFULL,3,2) /* force 2 decimals */
PGFULL = Left(PGFULL,3) /* keep intiger only */
Queue ' 'PGTYPE' 'PGFULL'% 'PARESZSL' 'PGUCB' ' ,
PGVOL' 'PGDSN
End /* do I=1 to partsize */
/*********************************************************************/
/* SCM - Storage Class Memory */
/* ASMVX - SYS1.MODGEN(ILRASMVX) pointed to in SYS1.MODGEN(ILRASMVT) */
/*********************************************************************/
/*If Bitand(CVTOSLV5,'01'x) = '01'x then do */ /* z/OS 1.13 and > */
SCMSTATUS = 'NOT-USED' /* set dflt to not used */
ASMVX = C2d(Storage(D2x(ASMVT + 1236),4)) /* point to ASM tbl ext */
SCMBLKSAVAIL = C2d(Storage(D2x(ASMVX + 8),8)) /* SCM blks avail */
SCMNVBC = C2d(Storage(D2x(ASMVX + 16),8)) /* SCM blks used */
SCMERRS = C2d(Storage(D2x(ASMVX + 24),8)) /* bad SCM blks */
If (SCMBLKSAVAIL > 0) then do /* SCM is used */
SCMSTATUS = 'IN-USE ' /* status is IN-USE */
SCMPCTUSED = Trunc(SCMNVBC*100/SCMBLKSAVAIL) /* percent used */
SCMPCTUSED = Format(SCMPCTUSED,3,2) /* format for display */
SCMPCTUSED = Left(SCMPCTUSED,3) /* format for display */
Call FORMAT_COMMAS SCMBLKSAVAIL /* format with commas */
SCMBLKSAVAIL = FORMATTED_WHOLENUM /* save number */
Call FORMAT_COMMAS SCMNVBC /* format with commas */
SCMNVBC = FORMATTED_WHOLENUM /* save number */
Call FORMAT_COMMAS SCMERRS /* format with commas */
SCMERRS = FORMATTED_WHOLENUM /* save number */
SCMBLKSAVAIL = Right(SCMBLKSAVAIL,16) /* format for display */
SCMNVBC = Right(SCMNVBC,16) /* format for display */
SCMERRS = Right(SCMERRS,16) /* format for display */
End
Queue ' '
Queue 'Storage Class Memory:'
Queue ' STATUS FULL SIZE USED' ,
' IN-ERROR'
If SCMSTATUS = 'NOT-USED' then Queue ' ' SCMSTATUS
Else do
Queue ' ' SCMSTATUS ' ' SCMPCTUSED || '% ' ,
SCMBLKSAVAIL SCMNVBC SCMERRS
End
End
Return
SMF: /* SMF Data Set information sub-routine */

Queue ' '
Queue 'SMF Data Set Usage:'
Queue ' Name Volser Size(Blks) %Full Status'
SMCAMISC = Storage(D2x(SMCA + 1),1) /* misc. indicators */
If bitand(SMCAMISC,'80'x) <> '80'x then do /* smf active ?? */
Queue ' *** SMF recording not being used ***'
Return
End
SMCAFRDS = C2d(Storage(D2x(SMCA + 244),4)) /* point to first RDS */
SMCALRDS = C2d(Storage(D2x(SMCA + 248),4)) /* point to last RDS */
SMCASMCX = C2d(Storage(D2x(SMCA + 376),4)) /* point to SMCX */
SMCXLSBT = Storage(D2x(SMCASMCX + 88),1) /* logstream bits */
If Bitand(SMCXLSBT,'80'x) = '80'x then do /* logstream recording? */
If SMCAFRDS = SMCALRDS then do
Queue ' *** SMF LOGSTREAM recording is active ***'
Queue ' *** LOGSTREAM information not available via REXX ***'
Return
End
Else do
Queue ' *** SMF LOGSTREAM recording is active ***'
Queue ' *** LOGSTREAM information not available via REXX ***'
Queue ' *** SMF data sets listed below not in use ***'
End
End /* If Bitand(SMCXLSBT,'80'x) */
If SMCAFRDS = SMCALRDS then do
Queue ' *** No SMF data sets available ***'
Return
End
Do until SMCAFRDS = SMCALRDS /* end loop when next rds ptr = last */
RDSNAME = Strip(Storage(D2x(SMCAFRDS + 16),44)) /* smf dsn */
RDSVOLID = Storage(D2x(SMCAFRDS + 60),6) /* smf volser */
RDSCAPTY = C2d(Storage(D2x(SMCAFRDS + 76),4)) /* size in blks */
RDSNXTBL = C2d(Storage(D2x(SMCAFRDS + 80),4)) /* next avl blk */
/* RDSPCT = (RDSNXTBL / RDSCAPTY) * 100 */ /* not how mvs does it */
RDSPCT = Trunc((RDSNXTBL / RDSCAPTY) * 100) /* same as mvs disp. */
RDSFLG1 = Storage(D2x(SMCAFRDS + 12),1) /* staus flags */
Select
When Bitand(RDSFLG1,'10'x) = '10'x then RDSSTAT = 'FREE REQUIRED'
When Bitand(RDSFLG1,'08'x) = '08'x then RDSSTAT = 'DUMP REQUIRED'
When Bitand(RDSFLG1,'04'x) = '04'x then RDSSTAT = 'ALTERNATE'
When Bitand(RDSFLG1,'02'x) = '02'x then RDSSTAT = 'CLOSE PENDING'
When Bitand(RDSFLG1,'01'x) = '01'x then RDSSTAT = 'OPEN REQUIRED'
When Bitand(RDSFLG1,'00'x) = '00'x then RDSSTAT = 'ACTIVE'
Otherwise RDSSTAT = '??????'
End /* Select */
If (RDSSTAT = 'ACTIVE' | RDSSTAT = 'DUMP REQUIRED') , /* display */
& RDSPCT = 0 then RDSPCT = 1 /* %full the same way mvs does */
SMCAFRDS = C2d(Storage(D2x(SMCAFRDS + 4),4)) /* point to next RDS */
If Length(RDSNAME) < 26 then do
Queue ' ' Left(RDSNAME,25,' ') RDSVOLID Right(RDSCAPTY,11,' ') ,
' 'Format(RDSPCT,5,0) ' ' RDSSTAT
End
Else do
Queue ' ' RDSNAME
Queue copies(' ',27) RDSVOLID Right(RDSCAPTY,11,' ') ,
' 'Format(RDSPCT,5,0) ' ' RDSSTAT
End
End
Return
SUB: /* Subsystem information sub-routine */

Arg SUBOPT
SSCVT = C2d(Storage(D2x(JESCT+24),4)) /* point to SSCVT */
SSCVT2 = SSCVT /* save address for second loop */
If SUBOPT <> 'FINDJES' then do
Queue ' '
Queue 'Subsystem Communications Vector Table:'
Queue ' Name Hex SSCTADDR SSCTSSVT' ,
' SSCTSUSE SSCTSUS2 Status'
End /* if subopt */
Do until SSCVT = 0
SSCTSNAM = Storage(D2x(SSCVT+8),4) /* subsystem name */
SSCTSSVT = C2d(Storage(D2x(SSCVT+16),4)) /* subsys vect tbl ptr */
SSCTSUSE = C2d(Storage(D2x(SSCVT+20),4)) /* SSCTSUSE pointer */
SSCTSUS2 = C2d(Storage(D2x(SSCVT+28),4)) /* SSCTSUS2 pointer */
If SUBOPT = 'FINDJES' & SSCTSNAM = JESPJESN then do
JESSSVT = SSCTSSVT /* save SSVTSSVT for "version" section */
/* this points to JES3 Subsystem Vector */
/* Table, mapped by IATYSVT */
JESSUSE = SSCTSUSE /* save SSCTSUSE for "version" section */
/* this points to version for JES2 */
JESSUS2 = SSCTSUS2 /* save SSCTSUS2 for "version" section */
/* this points to $HCCT for JES2 */
Leave /* found JES info for version section, exit loop */
End /* if subopt */
SSCTSNAX = C2x(SSCTSNAM) /* chg to EBCDIC for non-display chars */
Call XLATE_NONDISP SSCTSNAM /* translate non display chars */
SSCTSNAM = RESULT /* result from XLATE_NONDISP */
If SSCTSSVT = 0 then SSCT_STAT = 'Inactive'
Else SSCT_STAT = 'Active'
Queue ' ' SSCTSNAM ' ' SSCTSNAX ,
' ' Right(D2x(SSCVT),8,0) ' ' Right(D2x(SSCTSSVT),8,0) ,
' ' Right(D2x(SSCTSUSE),8,0) ' ' Right(D2x(SSCTSUS2),8,0) ,
' ' SSCT_STAT ' '
End /* if SUBOPT */
/*SSCTSSID = C2d(Storage(D2x(SSCVT+13),1)) */ /* subsys identifier */
/*If bitand(SSCTSSID,'02'x) = '02'x then JESPJESN = 'JES2' */
/*If bitand(SSCTSSID,'03'x) = '03'x then JESPJESN = 'JES3'*/
SSCVT = C2d(Storage(D2x(SSCVT+4),4)) /* next sscvt or zero */
End /* do until sscvt = 0 */
Queue ' '
Queue 'Supported Subsystem Function Codes:'
Do until SSCVT2 = 0 /* 2nd loop for function codes */
SSCTSNAM = Storage(D2x(SSCVT2+8),4) /* subsystem name */
SSCTSSVT = C2d(Storage(D2x(SSCVT2+16),4)) /* subsys vect tbl ptr */
SSCTSNAX = C2x(SSCTSNAM) /* chg to EBCDIC for non-display chars */
Call XLATE_NONDISP SSCTSNAM /* translate non display chars */
SSCTSNAM = RESULT /* result from XLATE_NONDISP */
Queue ' ' SSCTSNAM '(X''' || SSCTSNAX || ''')'
If SSCTSSVT <> 0 then do
SSVTFCOD = SSCTSSVT + 4 /* pt to funct. matrix*/
SSFUNCTB = Storage(D2X(SSVTFCOD),255) /* function matrix */
TOTFUNC = 0 /* counter for total functions per subsystem */
Drop FUNC. /* init stem to null for saved functions */
Do SUPFUNC = 1 TO 255
If Substr(SSFUNCTB,SUPFUNC,1) <> '00'x then do /* supported? */
TOTFUNC = TOTFUNC + 1 /* tot functions for this subsystem */
FUNC.TOTFUNC = SUPFUNC /* save function in stem */
End
End /* do supfunc */
/***************************************************************/
/* The following code is used to list the supported function */
/* codes by ranges. For example: 1-10,13,18-30,35,70,143-145 */
/***************************************************************/
If TOTFUNC >= 1 then do /* begin loop to list function codes */
ALLCODES = '' /* init var to nulls */
NEWRANGE = 'YES' /* init newrange flag to YES */
FIRSTRNG = 'YES' /* init firstrng flag to YES */
Do FCODES = 1 to TOTFUNC /* loop though codes */
JUNK = TOTFUNC + 1 /* prevent NOVALUE cond. */
FUNC.JUNK = '' /* in func.chknext at end */
CHKNEXT = FCODES + 1 /* stem var to chk next code */
If FUNC.FCODES + 1 = FUNC.CHKNEXT then do /* next matches */
If NEWRANGE = 'YES' & FIRSTRNG = 'YES' then do /* first */
ALLCODES = ALLCODES || FUNC.FCODES || '-' /* in new */
NEWRANGE = 'NO' /* range - seperate */
FIRSTRNG = 'NO' /* with a dash */
Iterate /* get next code */
End /* if newrange = 'yes' & firstrng = 'yes' */
If NEWRANGE = 'YES' & FIRSTRNG = 'NO' then do /* next */
ALLCODES = ALLCODES || FUNC.FCODES /* matches, but */
NEWRANGE = 'NO' /* is not the first, don't add dash */
Iterate /* get next code */
End /* if newrange = 'yes' & firstrng = 'no' */
Else iterate /* same range + not first - get next code */
End /* func.fcodes + 1 */
If FCODES = TOTFUNC then , /* next doesn't match and this */
ALLCODES = ALLCODES || FUNC.FCODES /* is the last code */
Else do /* next code doesn't match - seperate with comma */
ALLCODES = ALLCODES || FUNC.FCODES || ','
NEWRANGE = 'YES' /* re-init newrange flag to YES */
FIRSTRNG = 'YES' /* re-init firstrng flag to YES */
End
End /* do fcodes = 1 to totfunc */
/*************************************************************/
/* The code below splits up the ranges to multiple lines if */
/* they won't all fit on a single line due to IPLINFO lrecl. */
/*************************************************************/
FUN_MAXL = 68 /* max length b4 need to split out codes */
If Length(ALLCODES) <= FUN_MAXL then , /* fits on one line */
Queue ' Codes:' ALLCODES
Else do /* need to split up */
FUNSPLT = Pos(',',ALLCODES,FUN_MAXL-6) /* split at comma */
ALLCODES_1 = Substr(ALLCODES,1,FUNSPLT) /* 1st part */
ALLCODES_2 = Strip(Substr(ALLCODES,FUNSPLT+1,FUN_MAXL))
Queue ' Codes:' ALLCODES_1
Queue ' ' ALLCODES_2
End /* else do */
End /* if totfunc >= 1 */
End
Else queue ' *Inactive*'
SSCVT2 = C2d(Storage(D2x(SSCVT2+4),4)) /* next sscvt or zero */
End /* do until sscvt2 = 0 */
End /* if subopt <> 'findjes' */
Return
ASID: /* ASVT Usage sub-routine */

Queue ' '
CVTASVT = C2d(Storage(D2x(CVT+556),4)) /* point to ASVT */
ASVTMAXU = C2d(Storage(D2x(CVTASVT+516),4)) /* max number of entries */
ASVTMAXI = C2d(Storage(D2x(CVTASVT+500),4)) /* MAXUSERS from ASVT */
ASVTAAVT = C2d(Storage(D2x(CVTASVT+480),4)) /* free slots in ASVT */
ASVTSTRT = C2d(Storage(D2x(CVTASVT+492),4)) /* RSVTSTRT from ASVT */
ASVTAST = C2d(Storage(D2x(CVTASVT+484),4)) /* free START/SASI */
ASVTNONR = C2d(Storage(D2x(CVTASVT+496),4)) /* RSVNONR from ASVT */
ASVTANR = C2d(Storage(D2x(CVTASVT+488),4)) /* free non-reusable */
Queue 'ASID Usage Summary from the ASVT:'
Queue ' Maximum number of ASIDs:' Right(ASVTMAXU,5,' ')
Queue ' '
Queue ' MAXUSER from IEASYSxx:' Right(ASVTMAXI,5,' ')
Queue ' In use ASIDs:' Right(ASVTMAXI-ASVTAAVT,5,' ')
Queue ' Available ASIDs:' Right(ASVTAAVT,5,' ')
Queue ' '
Queue ' RSVSTRT from IEASYSxx:' Right(ASVTSTRT,5,' ')
Queue ' RSVSTRT in use:' Right(ASVTSTRT-ASVTAST,5,' ')
Queue ' RSVSTRT available:' Right(ASVTAST,5,' ')
Queue ' '
Queue ' RSVNONR from IEASYSxx:' Right(ASVTNONR,5,' ')
Queue ' RSVNONR in use:' Right(ASVTNONR-ASVTANR,5,' ')
Queue ' RSVNONR available:' Right(ASVTANR,5,' ')
Return
LPA: /* LPA List sub-routine */

CVTSMEXT = C2d(Storage(D2x(CVT + 1196),4)) /* point to stg map ext.*/
CVTEPLPS = C2d(Storage(D2x(CVTSMEXT+56),4)) /* start vaddr of ELPA */
NUMLPA = C2d(Storage(D2x(CVTEPLPS+4),4)) /* # LPA libs in table */
LPAOFF = 8 /* first ent in LPA tbl */
Queue ' '
Queue 'LPA Library List ('NUMLPA' libraries):'
Queue ' POSITION DSNAME'
Do I = 1 to NUMLPA
LEN = C2d(Storage(D2x(CVTEPLPS+LPAOFF),1)) /* length of entry */
LPDSN = Storage(D2x(CVTEPLPS+LPAOFF+1),LEN) /* DSN of LPA library */
LPAOFF = LPAOFF + 44 + 1 /* next entry in table*/
LPAPOS = Right(I,3) /* position in LPA list */
RELLPPOS = Right('(+'I-1')',6) /* relative position in list */
Queue LPAPOS RELLPPOS ' ' LPDSN
End
Return
LNKLST: /* LNKLST sub-routine */

If Bitand(CVTOSLV1,'01'x) <> '01'x then do /* below OS/390 R2 */
CVTLLTA = C2d(Storage(D2x(CVT + 1244),4)) /* point to lnklst tbl */
NUMLNK = C2d(Storage(D2x(CVTLLTA+4),4)) /* # LNK libs in table */
LLTAPFTB = CVTLLTA + 8 + (NUMLNK*45) /* start of LLTAPFTB */
LNKOFF = 8 /*first ent in LBK tbl */
LKAPFOFF = 0 /*first ent in LLTAPFTB*/
Queue ' '
Queue 'LNKLST Library List ('NUMLNK' Libraries):'
Queue ' POSITION APF DSNAME'
Do I = 1 to NUMLNK
LEN = C2d(Storage(D2x(CVTLLTA+LNKOFF),1)) /* length of entry */
LKDSN = Storage(D2x(CVTLLTA+LNKOFF+1),LEN) /* DSN of LNK lib */
CHKAPF = Storage(D2x(LLTAPFTB+LKAPFOFF),1) /* APF flag */
If bitand(CHKAPF,'80'x) = '80'x then LKAPF = 'Y' /* flag on */
else LKAPF = ' ' /* APF flag off */
LNKOFF = LNKOFF + 44 + 1 /*next entry in tbl*/
LKAPFOFF = LKAPFOFF + 1 /* next entry in LLTAPFTB */
LNKPOS = Right(I,3) /*position in list */
RELLKPOS = Right('(+'I-1')',6) /* relative position in list */
Queue LNKPOS RELLKPOS ' ' LKAPF ' ' LKDSN
End
End
Else do /* OS/390 1.2 and above - PROGxx capable LNKLST */
ASCB = C2d(Storage(224,4)) /* point to ASCB */
ASSB = C2d(Storage(D2x(ASCB+336),4)) /* point to ASSB */
DLCB = C2d(Storage(D2x(ASSB+236),4)) /* point to CSVDLCB */
DLCBFLGS = Storage(d2x(DLCB + 32),1) /* DLCB flag bits */
SETNAME = Storage(D2x(DLCB + 36),16) /* LNKLST set name */
SETNAME = Strip(SETNAME,'T') /* del trailing blanks*/
CVTLLTA = C2d(Storage(D2x(DLCB + 16),4)) /* point to lnklst tbl*/
LLTX = C2d(Storage(D2x(DLCB + 20),4)) /* point to LLTX */
NUMLNK = C2d(Storage(D2x(CVTLLTA+4),4)) /* # LNK libs in table*/
LLTAPFTB = CVTLLTA + 8 + (NUMLNK*45) /* start of LLTAPFTB */
LNKOFF = 8 /*first ent in LLT tbl*/
VOLOFF = 8 /*first ent in LLTX */
LKAPFOFF = 0 /*first ent in LLTAPFTB*/
If Bitand(DLCBFLGS,'10'x) = '10'x then , /* bit for LNKAUTH */
LAUTH = 'LNKLST' /* LNKAUTH=LNKLST */
Else LAUTH = 'APFTAB' /* LNKAUTH=APFTAB */
Queue ' '
Queue 'LNKLST Library List - Set:' SETNAME ,
' LNKAUTH='LAUTH '('NUMLNK' Libraries):'
If LAUTH = 'LNKLST' then ,
Queue ' (All LNKLST data sets marked APF=Y due to' ,
'LNKAUTH=LNKLST)'
Queue ' POSITION APF VOLUME DSNAME'
Do I = 1 to NUMLNK
LEN = C2d(Storage(D2x(CVTLLTA+LNKOFF),1)) /* length of entry */
LKDSN = Storage(D2x(CVTLLTA+LNKOFF+1),LEN) /* DSN of LNK lib */
LNKVOL = Storage(D2x(LLTX+VOLOFF),6) /* VOL of LNK lib */
CHKAPF = Storage(D2x(LLTAPFTB+LKAPFOFF),1) /* APF flag */
If bitand(CHKAPF,'80'x) = '80'x then LKAPF = 'Y' /* flag on */
else LKAPF = ' ' /* APF flag off */
LNKOFF = LNKOFF + 44 + 1 /*next entry in LLT*/
VOLOFF = VOLOFF + 8 /*next vol in LLTX */
LKAPFOFF = LKAPFOFF + 1 /* next entry in LLTAPFTB */
LNKPOS = Right(I,3) /*position in list */
RELLKPOS = Right('(+'I-1')',6) /* relative position in list */
Queue LNKPOS RELLKPOS ' ' LKAPF ' ' LNKVOL ' ' LKDSN
End
End
Return
APF: /* APF List sub-routine */

CVTAUTHL = C2d(Storage(D2x(CVT + 484),4)) /* point to auth lib tbl*/
If CVTAUTHL <> C2d('7FFFF001'x) then do /* dynamic list ? */
NUMAPF = C2d(Storage(D2x(CVTAUTHL),2)) /* # APF libs in table */
APFOFF = 2 /* first ent in APF tbl */
Queue ' '
Queue 'APF Library List ('NUMAPF' libraries):'
Queue ' ENTRY VOLUME DSNAME'
Do I = 1 to NUMAPF
LEN = C2d(Storage(D2x(CVTAUTHL+APFOFF),1)) /* length of entry */
VOL = Storage(D2x(CVTAUTHL+APFOFF+1),6) /* VOLSER of APF LIB */
DSN = Storage(D2x(CVTAUTHL+APFOFF+1+6),LEN-6) /* DSN of apflib */
APFOFF = APFOFF + LEN +1
APFPOS = Right(I,4) /*position in APF list*/
Queue ' 'APFPOS ' ' VOL ' ' DSN
End
End
Else Do
ECVT = C2d(Storage(D2x(CVT + 140),4)) /* point to CVTECVT */
ECVTCSVT = C2d(Storage(D2x(ECVT + 228),4)) /* point to CSV table */
APFA = C2d(Storage(D2x(ECVTCSVT + 12),4)) /* APFA */
AFIRST = C2d(Storage(D2x(APFA + 8),4)) /* First entry */
ALAST = C2d(Storage(D2x(APFA + 12),4)) /* Last entry */
LASTONE = 0 /* flag for end of list */
NUMAPF = 1 /* tot # of entries in list */
Do forever
DSN.NUMAPF = Storage(D2x(AFIRST+24),44) /* DSN of APF library */
DSN.NUMAPF = Strip(DSN.NUMAPF,'T') /* remove blanks */
CKSMS = Storage(D2x(AFIRST+4),1) /* DSN of APF library */
if bitand(CKSMS,'80'x) = '80'x /* SMS data set? */
then VOL.NUMAPF = '*SMS* ' /* SMS control dsn */
else VOL.NUMAPF = Storage(D2x(AFIRST+68),6) /* VOL of APF lib */
If Substr(DSN.NUMAPF,1,1) <> X2c('00') /* check for deleted */
then NUMAPF = NUMAPF + 1 /* APF entry */
AFIRST = C2d(Storage(D2x(AFIRST + 8),4)) /* next entry */
if LASTONE = 1 then leave
If AFIRST = ALAST then LASTONE = 1
End
Queue ' '
Queue 'APF Library List - Dynamic ('NUMAPF - 1' libraries):'
Queue ' ENTRY VOLUME DSNAME'
Do I = 1 to NUMAPF-1
APFPOS = Right(I,4) /*position in APF list*/
Queue ' 'APFPOS ' ' VOL.I ' ' DSN.I
End
End
Return
SVC: /* SVC information sub-routine */

/*********************************************************************/
/* See SYS1.MODGEN(IHASVC) for descriptions of SVC attributes */
/*********************************************************************/
CVTABEND = C2d(Storage(D2x(CVT+200),4)) /* point to CVTABEND */
SCVT = CVTABEND /* this is the SCVT - mapped by IHASCVT */
SCVTSVCT = C2d(Storage(D2x(SCVT+132),4)) /* point to SVCTABLE */
SCVTSVCR = C2d(Storage(D2x(SCVT+136),4)) /* point to SVC UPD TBL */
Call FIND_NUC 'IGCERROR' /* Find addr of IGCERROR in NUC MAP */
IGCERROR_ADDR = RESULT /* Save address of IGCERROR */
Call FIND_NUC 'IGCRETRN' /* Find addr of IGCRETRN in NUC MAP */
IGCRETRN_ADDR = RESULT /* Save address of IGCRETRN */
Call FIND_NUC 'IGXERROR' /* Find addr of IGXERROR in NUC MAP */
IGXERROR_ADDR = RESULT /* Save address of IGXERROR */
Call VMAP 'NODISP' /* call virt. stor map routine, "no display" */
/*********************************************************************/
/* The following code is needed to prevent errors in FIND_SVC_LOC */
/* routine "Select" because the VMAP sub-routine sets the address */
/* variables to "N/A" when MLPA/E-MLPA/FLPA/E-FLPA do not exist. */
/*********************************************************************/
If CVTMLPAS = 'N/A' then CVTMLPAS = 0 /* MLPA strt does not exist */
If CVTMLPAE = 'N/A' then CVTMLPAE = 0 /* MLPA end does not exist */
If CVTFLPAS = 'N/A' then CVTFLPAS = 0 /* FLPA strt does not exist */
If CVTFLPAE = 'N/A' then CVTFLPAE = 0 /* FLPA end does not exist */
If CVTEFLPS = 'N/A' then CVTEFLPS = 0 /* E-FLPA strt does not exist */
If CVTEFLPE = 'N/A' then CVTEFLPE = 0 /* E-FLPA end does not exist */
If CVTEMLPS = 'N/A' then CVTEMLPS = 0 /* E-MLPA strt does not exist */
If CVTEMLPE = 'N/A' then CVTEMLPE = 0 /* E-MLPA end does not exist */
/*********************************************************************/
/* A little house keeping */
/*********************************************************************/
SVCACT_TOT = 0 /* total number of active std SVCs */
SVCUNUSED_TOT = 0 /* total number of unused std SVCs */
SVCAPF_TOT = 0 /* total number of std SVCs requiring APF */
SVCESR_T1_TOT = 0 /* total number of active Type 1 ESR SVCs */
SVCESR_T3_TOT = 0 /* total number of active Type 3/4 ESR SVCs */
/*********************************************************************/
/* Standard SVC table display loop */
/*********************************************************************/
Queue ' '
Queue 'SVC Table:'
Queue ' Num Hex EP-Addr Location AM TYP APF ESR ASF AR NP UP' ,
'CNT Old-EPA LOCKS'
Do SVCLST = 0 to 255
SVCTENT = Storage(D2x(SCVTSVCT+(SVCLST*8)),8) /* SVC Table Entry */
SVCTENTU = Storage(D2x(SCVTSVCR+(SVCLST*24)),24) /* SVC UP TBL ENT */
SVCOLDA = Substr(SVCTENTU,1,4) /* OLD EP Address */
SVCOLDAR = C2x(SVCOLDA) /* OLD addr readable */
SVCOLDAR = Right(SVCOLDAR,8,'0') /* ensure leading zeros */
SVCURCNT = C2d(Substr(SVCTENTU,21,2)) /* SVC update count */
SVCAMODE = Substr(SVCTENT,1,1) /* AMODE indicator */
SVCEPA = Substr(SVCTENT,1,4) /* Entry point addr */
SVCEPAR = C2x(SVCEPA) /* EPA - readable */
SVCEPAR = Right(SVCEPAR,8,'0') /* ensure leading zeros */
SVCATTR1 = Substr(SVCTENT,5,1) /* SVC attributes */
SVCATTR3 = Substr(SVCTENT,6,1) /* SVC attributes */
SVCLOCKS = Substr(SVCTENT,7,1) /* Lock attributes */
/**************************/
/* Save EPAs of ESR SVCs */
/**************************/
If SVCLST = 109 then SVC109AD = SVCEPA
/**************************/
/* Check amode */
/**************************/
If Bitand(SVCAMODE,'80'x) = '80'x then SVC_AMODE = '31'
Else SVC_AMODE = '24'
/**************************/
/* Check SVC type flag */
/**************************/
Select /* determine SVC type */
When Bitand(SVCATTR1,'C0'x) = 'C0'x then SVCTYPE = '3/4'
When Bitand(SVCATTR1,'80'x) = '80'x then SVCTYPE = ' 2 '
Otherwise SVCTYPE = '???'
End /* select */
If SVCLST = 109 then SVCTYPE = ' 3 ' /* 109 is type 3 ESR, not 2 */
/**************************/
/* Check other SVC flags */
/**************************/
SVCAPF = ' ' ; SVCESR = ' ' ; SVCNP = ' ' /* init as blanks */
SVCASF = ' ' ; SVCAR = ' ' ; SVCUP = ' ' /* init as blanks */
If Bitand(SVCATTR1,'08'x) = '08'x then SVCAPF = 'APF'
If Bitand(SVCATTR1,'04'x) = '04'x then SVCESR = 'ESR'
If Bitand(SVCATTR1,'02'x) = '02'x then SVCNP = 'NP'
If Bitand(SVCATTR1,'01'x) = '01'x then SVCASF = 'ASF'
If Bitand(SVCATTR3,'80'x) = '80'x then SVCAR = 'AR'
If SVCURCNT <> 0 then SVCUP = 'UP' /* this SVC has been updated */
If SVCURCNT = 0 then do /* svc never updated */
SVCURCNT = ' '
SVCOLDAR = ' '
End
Else do /* most, if not all UP nums are sngl digit- center display */
If SVCURCNT < 10 then SVCURCNT = Right(SVCURCNT,2,' ') || ' '
Else SVCURCNT = Right(SVCURCNT,3,' ')
End /* else do */
/**************************/
/* Check lock flags */
/**************************/
SVCLL = ' ' ; SVCCMS = ' ' ; SVCOPT = ' ' /* init as blanks */
SVCALLOC = ' ' ; SVCDISP = ' ' /* init as blanks */
If Bitand(SVCLOCKS,'80'x) = '80'x then SVCLL = 'L' /* LOCAL */
If Bitand(SVCLOCKS,'40'x) = '40'x then SVCCMS = 'C' /* CMS */
If Bitand(SVCLOCKS,'20'x) = '20'x then SVCOPT = 'O' /* OPT */
If Bitand(SVCLOCKS,'10'x) = '10'x then SVCALLOC = 'S' /* SALLOC */
If Bitand(SVCLOCKS,'08'x) = '08'x then SVCDISP = 'D' /* DISP */
/*********************************/
/* location, location, location */
/*********************************/
SVCLOCA = Bitand(SVCEPA,'7FFFFFFF'x) /* zero high order bit */
SVCLOCA = C2d(SVCLOCA) /* need dec. for compare*/
Call FIND_SVC_LOC SVCLOCA /* determine SVC loc */
SVCLOC = RESULT /* Save Result */
If SVCLOCA = IGCERROR_ADDR | , /* this SVC */

SVCLOCA = IGCRETRN_ADDR then do /* is not used */
SVC_AMODE = ' ' /* blank out amode */
SVCAPF = '*** Not Used ***' /* replace other */
SVCESR = '' /* fields to line */
SVCASF = '' /* up "locks" due */
SVCAR = '' /* to "not used" */
SVCNP = '' /* display */
SVCUP = '' /* */
SVCURCNT = '' /* */
SVCOLDAR = ' ' /* */
SVCUNUSED_TOT = SVCUNUSED_TOT + 1 /* add 1 to unused tot */
End /* If SVCLOCA = IGCERROR_ADDR */
Else do /* used SVC */
SVCACT_TOT = SVCACT_TOT + 1 /* add 1 to tot active */
If SVCAPF = 'APF' then ,
SVCAPF_TOT = SVCAPF_TOT + 1 /* add 1 to APF total */
End /* Else do */
Queue ' ' Right(SVCLST,3,' ') '('Right(D2x(SVCLST),2,0)')' ,

SVCEPAR SVCLOC SVC_AMODE SVCTYPE SVCAPF SVCESR SVCASF ,
SVCAR SVCNP SVCUP SVCURCNT SVCOLDAR ,
SVCLL || SVCCMS || SVCOPT || SVCALLOC || SVCDISP
End /* Do SVCLST = 0 to 255 */
/*********************************************************************/
/* ESR SVC tables display loop */
/*********************************************************************/
Do SVCESRL = 1 to 4 /* ESR display loop */
If SVCESRL = 1 then do
SVCEAD = C2d(SVC116AD) /* Type 1 ESR tbl */
SVCEHD = 'Type 1 (SVC 116' /* Type/SVC for heading */
End
End
End
End
SVCESRMX = C2d(Storage(D2x(SVCEAD+4),4)) /* Max # ESR entries */
Queue ' '
Queue 'SVC Table for ESR' SVCEHD '- Maximum ESR Number Supported' ,
'is' SVCESRMX'):'
Queue ' Num Hex EP-Addr Location AM TYP APF ASF AR NP' ,
'LOCKS'
SVCEAD = SVCEAD + 8 /* bump past ESR hdr */
Do SVCELST = 0 to SVCESRMX
SVCETENT = Storage(D2x(SVCEAD+(SVCELST*8)),8) /* SVC Tbl Entry */
SVCEAMODE = Substr(SVCETENT,1,1) /* AMODE indicator */
SVCEEPA = Substr(SVCETENT,1,4) /* Entry point addr */
SVCEEPAR = C2x(SVCEEPA) /* EPA - readable */
SVCEEPAR = Right(SVCEEPAR,8,'0') /* ensure leading zeros */
SVCEATTR1 = Substr(SVCETENT,5,1) /* SVC attributes */
SVCEATTR3 = Substr(SVCETENT,6,1) /* SVC attributes */
SVCELOCKS = Substr(SVCETENT,7,1) /* Lock attributes */
/**************************/
/* Check amode */
/**************************/
If Bitand(SVCEAMODE,'80'x) = '80'x then SVCE_AMODE = '31'
Else SVCE_AMODE = '24'
/**************************/
/* Check SVC type flag */
/**************************/
Select /* determine SVC type */
When Bitand(SVCEATTR1,'C0'x) = 'C0'x then SVCETYPE = '3/4'
When Bitand(SVCEATTR1,'80'x) = '80'x then SVCETYPE = ' 2 '
Otherwise SVCETYPE = '???'
End /* select */
/**************************/
/* Check other SVC flags */
/**************************/
SVCEAPF = ' ' ; SVCENP = ' ' /* init as blanks */
SVCEASF = ' ' ; SVCEAR = ' ' /* init as blanks */
SVCEESR = ' '
If Bitand(SVCEATTR1,'08'x) = '08'x then SVCEAPF = 'APF'
If Bitand(SVCEATTR1,'04'x) = '04'x then SVCEESR = 'ESR'
If Bitand(SVCEATTR1,'02'x) = '02'x then SVCENP = 'NP'
If Bitand(SVCEATTR1,'01'x) = '01'x then SVCEASF = 'ASF'
If Bitand(SVCEATTR3,'80'x) = '80'x then SVCEAR = 'AR'
/**************************/
/* Check lock flags */
/**************************/
SVCELL = ' ' ; SVCECMS = ' ' ; SVCEOPT = ' ' /* init as blanks*/
SVCEALLOC = ' ' ; SVCEDISP = ' ' /* init as blanks*/
If Bitand(SVCELOCKS,'80'x) = '80'x then SVCELL = 'L' /* LOCAL */
If Bitand(SVCELOCKS,'40'x) = '40'x then SVCECMS = 'C' /* CMS */
If Bitand(SVCELOCKS,'20'x) = '20'x then SVCEOPT = 'O' /* OPT */
If Bitand(SVCELOCKS,'10'x) = '10'x then SVCEALLOC = 'S' /* SALLOC */
If Bitand(SVCELOCKS,'08'x) = '08'x then SVCEDISP = 'D' /* DISP */
/*********************************/
/* location, location, location */
/*********************************/
SVCELOCA = Bitand(SVCEEPA,'7FFFFFFF'x) /* zero high order bit */
SVCELOCA = C2d(SVCELOCA) /* need dec. for compare*/
Call FIND_SVC_LOC SVCELOCA /* determine SVC loc */
SVCELOC = RESULT /* Save Result */
If SVCELOCA = IGXERROR_ADDR then do /* this SVC is not used */
SVCE_AMODE = ' ' /* blank out amode */
SVCEAPF = '* Unused *' /* replace other fields */
SVCEASF = '' /* to line up "locks" */
SVCEAR = '' /* due to "unused" */
SVCENP = '' /* display */
End /* If SVCELOCA = IGXERROR_ADDR */
Else do /* used SVC */
If SVCESRL = 1 then ,
SVCESR_T1_TOT = SVCESR_T1_TOT + 1 /* add 1 to TYPE 1 tot */
SVCESR_T3_TOT = SVCESR_T3_TOT + 1 /* add 1 to TYPE 3/4 tot*/
End /* Else do */
Queue ' ' Right(SVCELST,3,' ') '('Right(D2x(SVCELST),2,0)')' ,

SVCEEPAR SVCELOC SVCE_AMODE SVCETYPE SVCEAPF SVCEASF ,
SVCEAR SVCENP ,
SVCELL || SVCECMS || SVCEOPT || SVCEALLOC || SVCEDISP
End
End /* Do SVCESRL = 1 to 4 */
Queue ' '
Queue ' SVC Usage Summary:'
Queue ' Total number of active standard SVCs (including ESR' ,
'slots) =' SVCACT_TOT
Queue ' Total number of unused standard SVCs =' SVCUNUSED_TOT
Queue ' Total number of active standard SVCs' ,
'requiring APF auth =' SVCAPF_TOT
Queue ' Total number of active Type 1 ESR SVCs =' SVCESR_T1_TOT
Queue ' Total number of active Type 3/4 ESR SVCs =' SVCESR_T3_TOT
Return
FIND_SVC_LOC: /* determine virtual storage location of SVC */

Arg SVC_LOC
Select
When SVC_LOC >= X2d(VVSTRT) & SVC_LOC <= X2d(VVEND) ,
then SVCLOC = 'PRIVATE ' /* never, but coded anyway */
When SVC_LOC >= X2d(GDACSAH) & SVC_LOC <= X2d(CSAEND) ,
then SVCLOC = 'CSA '
When SVC_LOC >= X2d(CVTMLPAS) & SVC_LOC <= X2d(CVTMLPAE) ,
then SVCLOC = 'MLPA '
When SVC_LOC >= X2d(CVTFLPAS) & SVC_LOC <= X2d(CVTFLPAE) ,
then SVCLOC = 'FLPA '
When SVC_LOC >= X2d(CVTPLPAS) & SVC_LOC <= X2d(CVTPLPAE) ,
then SVCLOC = 'PLPA '
When SVC_LOC >= X2d(GDASQAH) & SVC_LOC <= X2d(SQAEND) ,
then SVCLOC = 'SQA '
When SVC_LOC >= X2d(CVTRWNS) & SVC_LOC <= X2d(CVTRWNE) ,
then SVCLOC = 'R/W Nuc '
When SVC_LOC >= X2d(RONUCSZB) & SVC_LOC <= X2d('FFFFFF') ,
then SVCLOC = 'R/O Nuc '
When SVC_LOC >= X2d('1000000') & SVC_LOC <= X2d(CVTRONE) ,
then SVCLOC = 'E-R/O Nuc'
When SVC_LOC >= X2d(CVTERWNS) & SVC_LOC <= X2d(CVTERWNE) ,
then SVCLOC = 'E-R/W Nuc'
When SVC_LOC >= X2d(GDAESQAH) & SVC_LOC <= X2d(ESQAEND) ,
then SVCLOC = 'E-SQA '
When SVC_LOC >= X2d(CVTEPLPS) & SVC_LOC <= X2d(CVTEPLPE) ,
then SVCLOC = 'E-PLPA '
When SVC_LOC >= X2d(CVTEFLPS) & SVC_LOC <= X2d(CVTEFLPE) ,
then SVCLOC = 'E-FLPA '
When SVC_LOC >= X2d(CVTEMLPS) & SVC_LOC <= X2d(CVTEMLPE) ,
then SVCLOC = 'E-MLPA '
When SVC_LOC >= X2d(GDAECSAH) & SVC_LOC <= X2d(ECSAEND) ,
then SVCLOC = 'E-CSA '
When SVC_LOC >= X2d(GDAEPVTH) & SVC_LOC <= X2d(EPVTEND) ,
then SVCLOC = 'E-PRIVATE' /* never, but coded anyway */
Otherwise SVCLOC = '???? '
End /* select */
Return SVCLOC
FIND_NUC: /* Find EP address of "ARG" in NUC MAP */

Arg NUC_NAME
CVTNUCMP = C2d(Storage(D2x(CVT+1200),4)) /* NUC map address */
NUCMAPEND = C2d(Storage(D2x(CVTNUCMP+8),4)) /* End of nucmap */
/* NUCMAPLEN = C2d(Storage(D2x(CVTNUCMP+13),3)) */ /* tbl length */
NUC_CURA = CVTNUCMP+16 /* Curent tbl entry */
Do while NUC_CURA < NUCMAPEND /* go though tbl */
NUC_EP = Storage(D2x(NUC_CURA),8) /* Nuc EP name */
If NUC_EP = NUC_NAME then do /* NUC_NAME found? */
NUC_ADDR = C2d(Storage(D2x(NUC_CURA+8),4)) /* yes, save addr */
Leave /* leave this loop */
End /* If NUC_EP = NUC_NAME */
Else NUC_CURA = NUC_CURA + 16 /* bump to next entry */
End /* do while */
Return NUC_ADDR
XLATE_NONDISP: /* translate non-display characters to a "." */

Arg XLATEPRM
XLATELEN = Length(XLATEPRM) /* length of parm passed to routine */
Do I = 1 to XLATELEN /* check each byte for */
If (Substr(XLATEPRM,I,1) >= '00'x & , /* non-display characters */
Substr(XLATEPRM,I,1) < '40'x ) | , /* and replace each */
Substr(XLATEPRM,I,1) = 'FF'x then , /* character that */
XLATEPRM = OVERLAY('.',XLATEPRM,I) /* is non-displayable */
End /* with a period (.) */
Return XLATEPRM
STORAGE_GDA_LDA: /* GDA/LDA Storage values sub-routine */

ASCB = C2d(Storage(224,4)) /* point to cur ASCB */
ASCBLDA = C2d(Storage(D2x(ASCB + 48),4)) /* point to LDA */
CVTGDA = C2d(Storage(D2x(CVT + 560),4)) /* point to GDA */
LDASTRTA = Storage(D2x(ASCBLDA + 60),4) /* point to V=V start */
LDASTRTA = C2x(LDASTRTA) /* display in hex */
LDASIZEA = C2d(Storage(D2x(ASCBLDA + 64),4)) /* point to V=V size */
LDASIZEA = LDASIZEA/1024 /* convert to Kbytes */
LDASTRTS = Storage(D2x(ASCBLDA + 92),4) /* pt. to sysarea start */
LDASTRTS = C2x(LDASTRTS) /* display in hex */
LDASIZS = C2d(Storage(D2x(ASCBLDA + 96),4)) /* pt. to sysarea size */
LDASIZS = LDASIZS/1024 /* convert to Kbytes */
GDAPVTSZ = C2d(Storage(D2x(CVTGDA + 164),4)) /* point to MAX PVT<16M */
GDAPVTSZ = GDAPVTSZ/1024 /* convert to Kbytes */
GDAEPVTS = C2d(Storage(D2x(CVTGDA + 172),4)) /* point to MAX PVT>16M */
GDAEPVTS = GDAEPVTS/1024/1024 /* convert to Mbytes */
GDACSASZ = C2d(Storage(D2x(CVTGDA + 112),4)) /* point to CSA<16M */
GDACSASZ = GDACSASZ/1024 /* convert to Kbytes */
GDAECSAS = C2d(Storage(D2x(CVTGDA + 128),4)) /* point to CSA>16M */
GDAECSAS = GDAECSAS/1024 /* convert to Kbytes */
GDASQASZ = C2d(Storage(D2x(CVTGDA + 148),4)) /* point to SQA<16M */
GDASQASZ = GDASQASZ/1024 /* convert to Kbytes */
GDAESQAS = C2d(Storage(D2x(CVTGDA + 156),4)) /* point to SQA>16M */
GDAESQAS = GDAESQAS/1024 /* convert to Kbytes */
GDAVRSZ = C2d(Storage(D2x(CVTGDA + 196),4)) /* point to V=R global */
GDAVRSZ = GDAVRSZ/1024 /* convert to Kbytes */
GDAVREGS = C2d(Storage(D2x(CVTGDA + 200),4)) /* point to V=R default */
GDAVREGS = GDAVREGS/1024 /* convert to Kbytes */
GDA_CSA_ALLOC = C2d(Storage(D2x(CVTGDA + 432),4)) /* CSA amt alloc */
GDA_CSA_ALLOC = Format(GDA_CSA_ALLOC/1024,,0) /* conv to Kbytes */
GDA_ECSA_ALLOC = C2d(Storage(D2x(CVTGDA + 436),4)) /* ECSA amt alloc */
GDA_ECSA_ALLOC = Format(GDA_ECSA_ALLOC/1024,,0) /* conv to Kbytes */
GDA_SQA_ALLOC = C2d(Storage(D2x(CVTGDA + 440),4)) /* SQA amt alloc */
GDA_SQA_ALLOC = Format(GDA_SQA_ALLOC/1024,,0) /* conv to Kbytes */
GDA_ESQA_ALLOC = C2d(Storage(D2x(CVTGDA + 444),4)) /* ESQA amt alloc */
GDA_ESQA_ALLOC = Format(GDA_ESQA_ALLOC/1024,,0) /* conv to Kbytes */
GDA_CSA_CONV = C2d(Storage(D2x(CVTGDA + 448),4)) /* CSA => SQA amt */
GDA_CSA_CONV = Format(GDA_CSA_CONV/1024,,0) /* conv to Kbytes */
GDA_ECSA_CONV = C2d(Storage(D2x(CVTGDA + 452),4)) /* ECSA=>ESQA amt */
GDA_ECSA_CONV = Format(GDA_ECSA_CONV/1024,,0) /* conv to Kbytes */
/*********************************************************************/
/* High Water Marks for SQA/ESQA/CSA/ECSA added in OS/390 R10 */
/*********************************************************************/
GDASQAHWM = C2d(Storage(D2x(CVTGDA + 536),4)) /* SQA HWM */
GDASQAHWM = Format(GDASQAHWM/1024,,0) /* conv to Kbytes */
GDAESQAHWM = C2d(Storage(D2x(CVTGDA + 540),4)) /* ESQA HWM */
GDAESQAHWM = Format(GDAESQAHWM/1024,,0) /* conv to Kbytes */
GDATotalCSAHWM = C2d(Storage(D2x(CVTGDA+552),4)) /* CSA HWM */
GDATotalCSAHWM = Format(GDATotalCSAHWM/1024,,0) /* conv to Kb */
GDATotalECSAHWM = C2d(Storage(D2x(CVTGDA+556),4)) /* ECSA HWM */
GDATotalECSAHWM = Format(GDATotalECSAHWM/1024,,0) /* conv to Kb */
GDACSAHWM = GDATotalCSAHWM /* set var used for VMAP disp */
GDAECSAHWM = GDATotalECSAHWM /* set var used for VMAP disp */
End
Else do /* use pre z/OS 1.10 values for CSA/ECSA HWM */
GDACSAHWM = C2d(Storage(D2x(CVTGDA + 544),4)) /* CSA HWM */
GDACSAHWM = Format(GDACSAHWM/1024,,0) /* conv to Kbytes */
GDAECSAHWM = C2d(Storage(D2x(CVTGDA + 548),4)) /* ECSA HWM */
GDAECSAHWM = Format(GDAECSAHWM/1024,,0) /* conv to Kbytes */
End
End
Return
EXTRACT_SYSPARMS: /* Extract IEASYSxx values from the IPA */

Parse arg IEASPARM
IEASPARM = Strip(IEASPARM,'T') /* remove trailing blnks*/
If IEASPARM = '<notdef>' then return /*"blank" parm in IHAIPA*/
/*********************************************************************/
/* This next section of code removes IEASYSxx parameters from the */
/* IPA output display for parms that are obsolete or undocumented */
/* but still have to be accounted for when parsing out the parms */
/* and values from the IPA control block. */
/*********************************************************************/
If Bitand(CVTOSLV3,'08'x) = '08'x then , /* z/OS 1.3 and above */
If Substr(IEASPARM,1,3) = 'IPS'then return /* remove IPS parm */
If Pos('ILM',IEASPARM) <> 0 then return /* remove ILM parms */
If Pos('IQP',IEASPARM) <> 0 then return /* remove IQP parm */
If Pos('CPCR',IEASPARM) <> 0 then return /* remove CPCR parm */
If Pos('DDM',IEASPARM) <> 0 then return /* remove DDM parm */
End
If Pos('RTLS',IEASPARM) <> 0 then return /* remove RTLS parm */
End
/*********************************************************************/
IPAOFF = ((I-1) * 8) /* offset to next entry */
IPASTOR = D2x(ECVTIPA + 2152 + IPAOFF) /* point to PDE addr */
IPAPDE = C2x(Storage((IPASTOR),8)) /* point to PDE */
If IPAPDE = 0 then return /* parm not specified and has no default */
TOTPRMS = TOTPRMS + 1 /* tot num of specified or defaulted parms */
IPAADDR = Substr(IPAPDE,1,8) /* PARM address */
IPALEN = X2d(Substr(IPAPDE,9,4)) /* PARM length */
IPAPRM = Storage((IPAADDR),IPALEN) /* PARM */
IPASRC = Substr(IPAPDE,13,4) /* PARM source */
If X2d(IPASRC) = 65535 then PRMSRC = 'Operator' /* operator parm */
Else
If X2d(IPASRC) = 0 then PRMSRC = 'Default' /* default parm */
Else
PRMSRC = 'IEASYS' || X2c(IPASRC) /* IEASYSxx parm */
PRMLINE = ' 'IEASPARM'='IPAPRM
/**************************************************/
/* This check just below is for parms that do not */
/* have an equal sign in IEASYSxx. */
/**************************************************/
If IEASPARM = 'PRESCPU' | ,
IEASPARM = 'WARNUND' | ,
IEASPARM = 'CVIO' | ,
IEASPARM = 'CLPA' then PRMLINE = ' 'IEASPARM
Else PRMLINE = ' 'IEASPARM'='IPAPRM
PRMLINE.TOTPRMS = IEASPARM PRMLINE PRMSRC
PRMLINE.0 = TOTPRMS
Return
BUILD_IPAPDETB: /* Build table for lookup for IPA values */

NUM=1
IPAPDETB.NUM = 'ALLOC ' ; NUM = NUM + 1
IPAPDETB.NUM = 'APF ' ; NUM = NUM + 1
IPAPDETB.NUM = 'APG ' ; NUM = NUM + 1
IPAPDETB.NUM = 'BLDL ' ; NUM = NUM + 1
IPAPDETB.NUM = 'BLDLF ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CLOCK ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CLPA ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CMB ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CMD ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CON ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CONT ' ; NUM = NUM + 1
IPAPDETB.NUM = 'COUPLE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CPQE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CSA ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CSCBLOC ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CVIO ' ; NUM = NUM + 1
IPAPDETB.NUM = 'DEVSUP ' ; NUM = NUM + 1
IPAPDETB.NUM = 'DIAG ' ; NUM = NUM + 1
IPAPDETB.NUM = 'DUMP ' ; NUM = NUM + 1
IPAPDETB.NUM = 'DUPLEX ' ; NUM = NUM + 1
IPAPDETB.NUM = 'EXIT ' ; NUM = NUM + 1
IPAPDETB.NUM = 'FIX ' ; NUM = NUM + 1
IPAPDETB.NUM = 'GRS ' ; NUM = NUM + 1
IPAPDETB.NUM = 'GRSCNF ' ; NUM = NUM + 1
IPAPDETB.NUM = 'GRSRNL ' ; NUM = NUM + 1
IPAPDETB.NUM = 'ICS ' ; NUM = NUM + 1
IPAPDETB.NUM = 'IOS ' ; NUM = NUM + 1
IPAPDETB.NUM = 'IPS ' ; NUM = NUM + 1
IPAPDETB.NUM = 'LNK ' ; NUM = NUM + 1
IPAPDETB.NUM = 'LNKAUTH ' ; NUM = NUM + 1
IPAPDETB.NUM = 'LOGCLS ' ; NUM = NUM + 1
IPAPDETB.NUM = 'LOGLMT ' ; NUM = NUM + 1
IPAPDETB.NUM = 'LOGREC ' ; NUM = NUM + 1
IPAPDETB.NUM = 'LPA ' ; NUM = NUM + 1
IPAPDETB.NUM = 'MAXCAD ' ; NUM = NUM + 1
IPAPDETB.NUM = 'MAXUSER ' ; NUM = NUM + 1
IPAPDETB.NUM = 'MLPA ' ; NUM = NUM + 1
IPAPDETB.NUM = 'MSTRJCL ' ; NUM = NUM + 1
IPAPDETB.NUM = 'NONVIO ' ; NUM = NUM + 1
IPAPDETB.NUM = 'NSYSLX ' ; NUM = NUM + 1
IPAPDETB.NUM = 'NUCMAP ' ; NUM = NUM + 1
IPAPDETB.NUM = 'OMVS ' ; NUM = NUM + 1
End
Else do
IPAPDETB.NUM = 'RESERVED' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'OPI ' ; NUM = NUM + 1
IPAPDETB.NUM = 'OPT ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PAGE-OPR' ; NUM = NUM + 1
IPAPDETB.NUM = 'PAGE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PAGNUM ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PAGTOTL ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PAK ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PLEXCFG ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PROD ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PROG ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PURGE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'RDE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'REAL ' ; NUM = NUM + 1
IPAPDETB.NUM = 'RER ' ; NUM = NUM + 1
IPAPDETB.NUM = 'RSU ' ; NUM = NUM + 1
IPAPDETB.NUM = 'RSVNONR ' ; NUM = NUM + 1
IPAPDETB.NUM = 'RSVSTRT ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SCH ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SMF ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SMS ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SQA ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SSN ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SVC ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SWAP ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SYSNAME ' ; NUM = NUM + 1
IPAPDETB.NUM = 'SYSP ' ; NUM = NUM + 1
IPAPDETB.NUM = 'VAL ' ; NUM = NUM + 1
IPAPDETB.NUM = 'VIODSN ' ; NUM = NUM + 1
IPAPDETB.NUM = 'VRREGN ' ; NUM = NUM + 1
IPAPDETB.NUM = 'RTLS ' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'UNI ' ; NUM = NUM + 1 /* added by APAR OW44581*/
End
IPAPDETB.NUM = 'ILMLIB ' ; NUM = NUM + 1
IPAPDETB.NUM = 'ILMMODE ' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'IKJTSO ' ; NUM = NUM + 1
IPAPDETB.NUM = 'LICENSE ' ; NUM = NUM + 1
End
IPAPDETB.NUM = '<notdef>' ; NUM = NUM + 1 /*"blank" def in IHAIPA */
IPAPDETB.NUM = 'HVSHARE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'ILM ' ; NUM = NUM + 1
/********************************************************************/
/* If you have a z/OS 1.5 or z/OS 1.6 system without OA09649, you */
/* may have to delete the next 3 lines of code. */
/********************************************************************/
IPAPDETB.NUM = 'PRESCPU ' ; NUM = NUM + 1 /* added by OA09649 */
End
NUM = NUM-3
IPAPDETB.NUM = 'DRMODE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'CEE ' ; NUM = NUM + 1
IPAPDETB.NUM = 'PRESCPU ' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'LFAREA ' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'CEA ' ; NUM = NUM + 1
IPAPDETB.NUM = 'HVCOMMON' ; NUM = NUM + 1
IPAPDETB.NUM = 'AXR ' ; NUM = NUM + 1
End
/********************************************************************/
/* If you have z/OS 1.10 without OA27495, you may have to delete */
/* the next line of code. If you have z/OS 1.9 with OA27495 and */
/* wish to see the "ZZ" value, change the check above from: */
/* If Bitand(CVTOSLV5,'08'x) = '08'x then do */
/* to: */
/* If Bitand(CVTOSLV5,'10'x) = '10'x then do */
/********************************************************************/
IPAPDETB.NUM = 'ZZ ' ; NUM = NUM + 1
End
NUM = NUM - 1
IPAPDETB.NUM = 'ZAAPZIIP' ; NUM = NUM + 1
IPAPDETB.NUM = 'IQP' ; NUM = NUM + 1
IPAPDETB.NUM = 'CPCR' ; NUM = NUM + 1
IPAPDETB.NUM = 'DDM' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'AUTOR' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'CATALOG' ; NUM = NUM + 1
IPAPDETB.NUM = 'IXGCNF' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'PAGESCM' ; NUM = NUM + 1
IPAPDETB.NUM = 'WARNUND' ; NUM = NUM + 1
IPAPDETB.NUM = 'HZS' ; NUM = NUM + 1
IPAPDETB.NUM = 'GTZ' ; NUM = NUM + 1
IPAPDETB.NUM = 'HZSPROC' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'SMFLIM' ; NUM = NUM + 1
IPAPDETB.NUM = 'IEFOPZ' ; NUM = NUM + 1
End
IPAPDETB.NUM = 'RACF' ; NUM = NUM + 1
IPAPDETB.NUM = 'FXE' ; NUM = NUM + 1
IPAPDETB.NUM = 'IZU' ; NUM = NUM + 1
IPAPDETB.NUM = 'SMFTBUFF' ; NUM = NUM + 1 /* APAR OA52828 */
IPAPDETB.NUM = 'DIAG1' ; NUM = NUM + 1 /* IBM use only */
IPAPDETB.NUM = 'OSPROTECT'; NUM = NUM + 1 /* APAR OA54807 */
IPAPDETB.NUM = 'ICSF' ; NUM = NUM + 1 /* APAR OA55378 */
IPAPDETB.NUM = 'ICSFPROC' ; NUM = NUM + 1 /* APAR OA55378 */
End
IPAPDETB.0 = NUM-1
Return
SPLIT_IPA_PAGE: /* Split up page data set parms to multiple lines */

TOT_IPALINES = 0
Do SPLIT = 1 to PRMLINE.0
TOT_IPALINES = TOT_IPALINES+1 /* add one total lines */
IPA_PDE = Word(PRMLINE.SPLIT,1) /* keyword */
IPA_PRM = Word(PRMLINE.SPLIT,2) /* value */
IPA_SRC = Word(PRMLINE.SPLIT,3) /* IEASYSxx, dlft, or OPR */
IPA_LEN = Length(IPA_PRM)
If IPA_PDE = 'NONVIO' | IPA_PDE = 'PAGE' | ,
IPA_PDE = 'PAGE-OPR' | IPA_PDE = 'SWAP' then do
MORE = 'YES' /* init flag for more subparms */
FIRST = 'YES' /* init flag for first subparm */
SPLITPOS = 1
Do until MORE = 'NO'
SPLITPOS = Pos(',',IPA_PRM)
If SPLITPOS = 0 then do
If FIRST = 'YES' then do
IPALINE.TOT_IPALINES = ' 'IPA_PRM || ','
IPALINE.TOT_IPALINES = ,
Overlay(IPA_SRC,IPALINE.TOT_IPALINES,68)
End
Else do
MBLNK = ''
If IPA_PDE = 'NONVIO' then MBLNK = ' ' /* align */
If IPA_PDE = 'PAGE-OPR' then MBLNK = ' ' /* align */
IPALINE.TOT_IPALINES = MBLNK' 'IPA_PRM || ','
IPALINE.TOT_IPALINES = ,
Overlay(IPA_SRC,IPALINE.TOT_IPALINES,68)
End
MORE = 'NO' /* no more subparms */
End /* if SPLITPOS = 0 */
Else do
IPAPRM_SPLIT = Substr(IPA_PRM,1,SPLITPOS)
If FIRST = 'YES' then IPALINE.TOT_IPALINES = ' 'IPAPRM_SPLIT
Else do
MBLNK = ''
If IPA_PDE = 'NONVIO' then MBLNK = ' ' /* align */
If IPA_PDE = 'PAGE-OPR' then MBLNK = ' ' /* align */
IPALINE.TOT_IPALINES = MBLNK' 'IPAPRM_SPLIT
End
IPA_PRM = Substr(IPA_PRM,SPLITPOS+1,IPA_LEN-SPLITPOS)
IPA_LEN = Length(IPA_PRM)
TOT_IPALINES = TOT_IPALINES+1 /* add one total lines */
FIRST = 'NO'
End
End /* do until more=no */
End
Else do
IPALINE.TOT_IPALINES = ' 'IPA_PRM || ','
IPALINE.TOT_IPALINES = Overlay(IPA_SRC,IPALINE.TOT_IPALINES,68)
End
End
Return
SORT_IPA: Procedure expose PRMLINE.

/* bubble sort the IPA list */
SORT_DONE = 0
SORT_RECS = PRMLINE.0
Do while SORT_DONE = 0
SORT_DONE = 1
Do I = 1 to SORT_RECS - 1
J = I + 1
If PRMLINE.I > PRMLINE.J then do
SORT_DONE = 0
TEMP_SORT = PRMLINE.J
PRMLINE.J = PRMLINE.I
PRMLINE.I = TEMP_SORT
End /* if */
End /* do i=1 to sort_recs */
SORT_RECS = SORT_RECS - 1
End /* do while */
Return
GET_CPCSI:
SI_OFF=0
IRALCCT = C2d(Storage(D2x(RMCT+620),4)) /* point to IRALCCT */
/* (undocumented) */
SI_OFF = 128 /* additional offset to CPC SI info in IRALCCT */
/****************************************************************/
/* If you have z/OS 1.12 or z/OS 1.13 with z13 support */
/* maintenance applied you will have to uncomment either the */
/* first 2 lines or the 2nd 2 lines to fix the CPCSI display. */
/* The 2nd set should work for z/OS 1.12 or z/OS 1.13 systems */
/* that do have the maintenance and also for those systems that */
/* do not have the maintenance. */
/****************************************************************/
/*If Bitand(CVTOSLV5,'02'x) = '02'x then , */ /* z/OS 1.12 and > */
/* SI_OFF = 384 */ /* additional offset to CPC SI info in IRALCCT */
/*If C2x(Storage(D2x(IRALCCT+10),1)) <> '40' then , *//* z13 support */
/* SI_OFF = 384 */ /* additional offset to CPC SI info in IRALCCT */
/****************************************************************/
/* The check below was added for a reported problem on */
/* z/OS 2.3 at RSU1812 or RSU1903. I'm not sure what APAR(s) */
/* broke this or if the same APAR could apply to earlier z/OS */
/* versions. */
/* */
/* If the CPU node display doesn't look right, delete the code */
/* that changes the offset to 392 or comment it out. */
/****************************************************************/
If Bitand(CVTOSLV6,'10'x) = '10'x then /* z/OS 2.3 and above */
/* (MODEL='3906' | MODEL='3907') | */ /* z/OS 2.3 + z14 */
/* (MODEL='2964' | MODEL='2965') then */ /* z/OS 2.3 + z13 */
CPCSI_TYPE = Storage(D2x(IRALCCT+332+SI_OFF),4) /* Type */
CPCSI_MODEL = Storage(D2x(IRALCCT+336+SI_OFF),4) /* Model */
CPCSI_MODEL = Strip(CPCSI_MODEL) /* Remove blanks */
CPCSI_MAN = Storage(D2x(IRALCCT+384+SI_OFF),16) /* Manufacturer */
CPCSI_MAN = Strip(CPCSI_MAN) /* Remove blanks */
CPCSI_PLANT = Storage(D2x(IRALCCT+400+SI_OFF),4) /* Plant */
CPCSI_PLANT = Strip(CPCSI_PLANT) /* Remove blanks */
CPCSI_CPUID = Storage(D2x(IRALCCT+352+SI_OFF),16) /* CPUID */
CPCSI_MODELID = Storage(D2x(IRALCCT+592+SI_OFF),4) /* Model ID */
CPCSI_MODELID = Strip(CPCSI_MODELID) /* Remove blanks */
/* CPCSI_MODELID may not be valid on emulated */
/* z/OS systems like FLEX, HERC and z/PDT */
Return
FORMAT_MEMSIZE:
/****************************************************************/
/* The following code is used to display the storage size in */
/* the largest possible unit. For example, 1023G and 1025G are */
/* displayed as 1023G and 1025G, but 1024G is displayed as 1T. */
/* The size passed to the routine must be in MB. */
/****************************************************************/
Arg SIZE_IN_MB
Select
When SIZE_IN_MB < 1024 then do
MUNITS = 'M'
End
When SIZE_IN_MB >= 1024 & SIZE_IN_MB < 1048576 then do
If SIZE_IN_MB/1024 == TRUNC(SIZE_IN_MB/1024) then do
SIZE_IN_MB = SIZE_IN_MB/1024
MUNITS = 'G'
End
Else MUNITS = 'M'
End
When SIZE_IN_MB >= 1048576 & SIZE_IN_MB < 1073741824 then do
MUNITS = 'T'
End
Else do
MUNITS = 'G'
End
Else MUNITS = 'M'
End
End
When SIZE_IN_MB >= 1073741824 & ,
SIZE_IN_MB <= 17591112302592 then do
If SIZE_IN_MB/1073741824 == TRUNC(SIZE_IN_MB/1073741824) ,
then do
MUNITS = 'P'
End
Else do
MUNITS = 'T'
End
End
When SIZE_IN_MB = 17592186040320 then do
SIZE_IN_MB = 'NOLIMIT' /* 16384P */
MUNITS = ''
End
When SIZE_IN_MB > 17592186040320 then do
SIZE_IN_MB = '*NOLIMT' /* >16384P (16EB) ?? */
MUNITS = ''
End
Otherwise do
Queue ' '
Queue 'Error in FORMAT_MEMSIZE code. Contact Mark Zelden.'
Queue 'SIZE_IN_MB=' SIZE_IN_MB
Queue ' '
SIZE_IN_MB = '*ERROR*'
MUNITS = ''
End
End /* select */
STOR_SIZE = SIZE_IN_MB || MUNITS
Return STOR_SIZE
BROWSE_ISPF: /* Browse output if ISPF is active */

Address ISPEXEC "CONTROL ERRORS RETURN"
Address TSO
prefix = sysvar('SYSPREF') /* tso profile prefix */
uid = sysvar('SYSUID') /* tso userid */
If prefix = '' then prefix = uid /* use uid if null prefix */
If prefix <> '' & prefix <> uid then /* different prefix than uid */
prefix = prefix || '.' || uid /* use prefix.uid */
ddnm1 = 'DDO'||random(1,99999) /* choose random ddname */
ddnm2 = 'DDP'||random(1,99999) /* choose random ddname */
junk = MSG('OFF')
"ALLOC FILE("||ddnm1||") UNIT(SYSALLDA) NEW TRACKS SPACE(2,1) DELETE",
" REUSE LRECL(80) RECFM(F B) BLKSIZE(3120)"
"ALLOC FILE("||ddnm2||") UNIT(SYSALLDA) NEW TRACKS SPACE(1,1) DELETE",
" REUSE LRECL(80) RECFM(F B) BLKSIZE(3120) DIR(1)"
junk = MSG('ON')
"Newstack"
/*************************/
/* IPLINFOP Panel source */
/*************************/
If Substr(ZENVIR,6,1) >= 4 then
If EDITOP = 'YES' then ,
Queue ")PANEL KEYLIST(ISRSPEC,ISR)"
Else ,
Queue ")PANEL KEYLIST(ISRSPBC,ISR)"
Queue ")ATTR"
Queue " _ TYPE(INPUT) INTENS(HIGH) COLOR(TURQ) CAPS(OFF)" ,
"FORMAT(&MIXED)"
Queue " | AREA(DYNAMIC) EXTEND(ON) SCROLL(ON) USERMOD('20')"
Else ,
Queue " | AREA(DYNAMIC) EXTEND(ON) SCROLL(ON)"
Queue " + TYPE(TEXT) INTENS(LOW) COLOR(BLUE)"
Queue " @ TYPE(TEXT) INTENS(LOW) COLOR(TURQ)"
Queue " % TYPE(TEXT) INTENS(HIGH) COLOR(GREEN)"
Queue " ! TYPE(OUTPUT) INTENS(HIGH) COLOR(TURQ) PAD(-)"
Queue " 01 TYPE(DATAOUT) INTENS(LOW)"
Queue " 02 TYPE(DATAOUT) INTENS(HIGH)"
If EDITOP = 'YES' then do
Queue " 03 TYPE(DATAOUT) SKIP(ON) /* FOR TEXT ENTER CMD. FIELD */"
Queue " 04 TYPE(DATAIN) INTENS(LOW) CAPS(OFF) FORMAT(&MIXED)"
Queue " 05 TYPE(DATAIN) INTENS(HIGH) CAPS(OFF) FORMAT(&MIXED)"
Queue " 06 TYPE(DATAIN) INTENS(LOW) CAPS(IN) FORMAT(&MIXED)"
Queue " 07 TYPE(DATAIN) INTENS(HIGH) CAPS(IN) FORMAT(&MIXED)"
Queue " 08 TYPE(DATAIN) INTENS(LOW) FORMAT(DBCS) OUTLINE(L)"
Queue " 09 TYPE(DATAIN) INTENS(LOW) FORMAT(EBCDIC) OUTLINE(L)"
Queue " 0A TYPE(DATAIN) INTENS(LOW) FORMAT(&MIXED) OUTLINE(L)"
Queue " 0D TYPE(DATAIN) INTENS(LOW) CAPS(IN) FORMAT(&MIXED)" || ,
" COLOR(BLUE)"
Queue " 20 TYPE(DATAIN) INTENS(LOW) CAPS(IN) FORMAT(&MIXED)"
End
Else do
Queue " 0B TYPE(DATAOUT) INTENS(HIGH) FORMAT(DBCS)"
Queue " 0C TYPE(DATAOUT) INTENS(HIGH) FORMAT(EBCDIC)"
Queue " 0D TYPE(DATAOUT) INTENS(HIGH) FORMAT(&MIXED)"
Queue " 10 TYPE(DATAOUT) INTENS(LOW) FORMAT(DBCS)"
Queue " 11 TYPE(DATAOUT) INTENS(LOW) FORMAT(EBCDIC)"
Queue " 12 TYPE(DATAOUT) INTENS(LOW) FORMAT(&MIXED)"
End
Queue ")BODY WIDTH(&ZWIDTH) EXPAND(//)"
Queue "@EDIT @&ZTITLE / / %Columns!ZCL !ZCR +"
End
Else do
Queue ")BODY EXPAND(//)"
Queue "%BROWSE @&ZTITLE / / %Line!ZLINES %Col!ZCOLUMS+"
End
Queue "%Command ===>_ZCMD / / %Scroll ===>_Z +"
Queue "|ZDATA ---------------/ /-------------------------|"
Queue "| / / |"
Queue "| --------------------/-/-------------------------|"
Queue ")INIT"
Queue " .HELP = IPLINFOH"
Queue " .ZVARS = 'ZSCED'"
Else ,
Queue " .ZVARS = 'ZSCBR'"
Queue " &ZTITLE = 'Mark''s MVS Utilities - IPLINFO'"
Queue " &MIXED = MIX"
Queue " IF (&ZPDMIX = N)"
Queue " &MIXED = EBCDIC"
Queue " VGET (ZSCED) PROFILE"
Queue " IF (&ZSCED = ' ')"
Queue " &ZSCED = 'CSR'"
End
Else do
Queue " VGET (ZSCBR) PROFILE"
Queue " IF (&ZSCBR = ' ')"
Queue " &ZSCBR = 'CSR'"
End
Queue ")REINIT"
Queue " .HELP = IPLINFOH"
Queue " REFRESH(ZCMD,ZSCED,ZDATA,ZCL,ZCR)"
Else ,
Queue " REFRESH(ZCMD,ZSCBR,ZDATA,ZLINES,ZCOLUMS)"
Queue ")PROC"
Queue " &ZCURSOR = .CURSOR"
Queue " &ZCSROFF = .CSRPOS"
Queue " &ZLVLINE = LVLINE(ZDATA)"
Queue " VPUT (ZSCED) PROFILE"
Else ,
Queue " VPUT (ZSCBR) PROFILE"
Queue ")END"
/* */
Address ISPEXEC "LMINIT DATAID(PAN) DDNAME("ddnm2")"
Address ISPEXEC "LMOPEN DATAID("pan") OPTION(OUTPUT)"
Do queued()
Parse pull panline
Address ISPEXEC "LMPUT DATAID("pan") MODE(INVAR)" ,
"DATALOC(PANLINE) DATALEN(80)"
End
Address ISPEXEC "LMMADD DATAID("pan") MEMBER(IPLINFOP)"
/* Address ISPEXEC "LMFREE DATAID("pan")" */
"Delstack"
"Newstack"
/*************************/
/* IPLINFOH Panel source */
/*************************/
If Substr(ZENVIR,6,1) >= 4 then
Queue ")PANEL KEYLIST(ISRSPBC,ISR)"
Queue ")ATTR DEFAULT(!+_)"
Queue " _ TYPE(INPUT) INTENS(HIGH) COLOR(TURQ) CAPS(OFF)" ,
"FORMAT(&MIXED)"
Queue " + TYPE(TEXT) INTENS(LOW) COLOR(BLUE)"
Queue " @ TYPE(TEXT) INTENS(LOW) COLOR(TURQ)"
Queue " ! TYPE(TEXT) INTENS(HIGH) COLOR(GREEN)"
Queue " # AREA(SCRL) EXTEND(ON)"
Queue ")BODY EXPAND(//)"
Queue "!HELP @&ZTITLE / / "
Queue "!Command ===>_ZCMD / / "
Queue "#IPLHSCR " || ,
" #"
Queue ")AREA IPLHSCR"
Queue "@EXECUTION SYNTAX:!TSO %IPLINFO <option> "
Queue "+VALID OPTIONS ARE 'ALL', 'IPL', 'VERsion'," ||,
" 'STOrage', 'CPU', 'IPA', 'SYMbols',"
Queue "+ 'VMAp', 'PAGe', 'SMF', " ||,
"'SUB', 'ASId', 'LPA', 'LNKlst', 'APF' and 'SVC'"
Queue "@**+OPTIONS may be abbreviated by using 3 or more characters "
Queue "+Examples: "
Queue "! TSO %IPLINFO +(Display all Information) "
Queue "! TSO %IPLINFO IPL +(Display IPL Information) "
Queue "! TSO %IPLINFO VER +(Display Version Information) "
Queue "! TSO %IPLINFO STOR +(Display Storage Information) "
Queue "! TSO %IPLINFO CPU +(Display CPU Information) "
Queue "! TSO %IPLINFO IPA +(Display Initialization Information) "
Queue "! TSO %IPLINFO SYM +(Display Static System Symbols) "
Queue "! TSO %IPLINFO VMAP +(Display a Virtual Storage Map) "
Queue "! TSO %IPLINFO PAGE +(Display Page Data Set Usage",
"Information)"
Queue "! TSO %IPLINFO SMF +(Display SMF Data Set Usage Information)"
Queue "! TSO %IPLINFO SUB +(Display Subsystem Information) "
Queue "! TSO %IPLINFO ASID +(Display ASID Usage Information) "
Queue "! TSO %IPLINFO LPA +(Display LPA List Information) "
Queue "! TSO %IPLINFO LNK +(Display LNKLST Information) "
Queue "! TSO %IPLINFO APF +(Display APF List Information) "
Queue "! TSO %IPLINFO SVC +(Display SVC Information) "
Queue "@&ADLINE"
Queue ")INIT"
Queue " .HELP = ISR10000"
Queue " &ZTITLE = 'Mark''s MVS Utilities - IPLINFO'"
Queue " &L1 = 'Mark''s MVS Utilities -'"
Queue " &L2 = 'http://www.mzelden.com/mvsutil.html'"
Queue " &ADLINE = '&L1 &L2'"
Queue " &MIXED = MIX"
Queue " IF (&ZPDMIX = N)"
Queue " &MIXED = EBCDIC"
Queue ")END"
/* */
Do queued()
Parse pull panline
Address ISPEXEC "LMPUT DATAID("pan") MODE(INVAR)" ,
"DATALOC(PANLINE) DATALEN(80)"
End
Address ISPEXEC "LMMADD DATAID("pan") MEMBER(IPLINFOH)"
Address ISPEXEC "LMFREE DATAID("pan")"
"Delstack"
"EXECIO" Queued() "DISKW" ddnm1 "(FINIS"
zerrsm = 'IPLINFO' LASTUPD
zerrlm = 'IPLINFO -' OPTION 'option.' ,
'Last updated on' LASTUPD ||'. Written by' ,
'Mark Zelden. Mark''s MVS Utilities -' ,
'http://www.mzelden.com/mvsutil.html'
zerralrm = 'NO' /* msg - no alarm */
zerrhm = 'IPLINFOH' /* help panel */
address ISPEXEC "LIBDEF ISPPLIB LIBRARY ID("||ddnm2||") STACK"
address ISPEXEC "SETMSG MSG(ISRZ002)"
address ISPEXEC "LMINIT DATAID(TEMP) DDNAME("||ddnm1||")"
address ISPEXEC "EDIT DATAID("||temp") PANEL(IPLINFOP)"
Else ,
address ISPEXEC "BROWSE DATAID("||temp") PANEL(IPLINFOP)"
address ISPEXEC "LMFREE DATAID("||temp")"
address ISPEXEC "LIBDEF ISPPLIB"
junk = MSG('OFF')
"FREE FI("||ddnm1||")"
"FREE FI("||ddnm2||")"
Return
REXXTOD:
/* REXX */
/* */
/* */
/***********************************************************/
/* Convert TOD string which is units since January 1, 1990 */
/* Result is in format of YYYY.DDD HH:MM:SS.ttt */
/* */
/* Examples: */
/* REXXTOD B92E37543F000000 --> 2003.086 05:06:06.435 */
/* REXXTOD C653258535522000 --> 2010.205 13:23:45.154 */
/* REXXTOD C8B8D8A516A77000 --> 2011.328 16:09:07.768 */
/***********************************************************/
Arg TODIN
/* Numeric Digits 16 */ /* commented out, IPLINFO already higher */
TODIN = Left(TODIN,13,0) /* rtn can only handle 1000s of a second */
TODIN = X2d(TODIN) /* convert to decimal for arithmetic */
TODIN = TODIN % 1000
TTT = TODIN // 1000 /* 1000s of a second - ".ttt" */
TODIN = TODIN % 1000
SS = TODIN // 60; /* Seconds - "SS" */
TODIN = TODIN % 60
MM = TODIN // 60; /* Minutes - "MM" */
TODIN = TODIN % 60
HH = TODIN // 24; /* Hours - "HH" */
TODIN = TODIN % 24
TODIN = TODIN + 1 /* add 1 to remainder, needed for next */

/* section of code taken from "RDATE" */
/* Determine YYYY and DDD */

if TODIN>365 then TODIN=TODIN+1
YEARS_X4=(TODIN-1)%1461
DDD=TODIN-YEARS_X4*1461
if TODIN > 73415 then DDD = DDD +1
EXTRA_YEARS=(DDD*3-3)%1096
DDD=DDD-(EXTRA_YEARS*1096+2)%3
YYYY=YEARS_X4*4+EXTRA_YEARS+1900
/* Format prior to result */

DDD = Right(DDD,3,'0')
HH = Right(HH,2,'0')
MM = Right(MM,2,'0')
SS = Right(SS,2,'0')
TTT = Right(TTT,3,'0')
TOD_VAL = YYYY'.'DDD HH':'MM':'SS'.'TTT

/* Say TOD_VAL; Exit 0 */
Return TOD_VAL
FORMAT_COMMAS:
/* REXX - Format whole number with commas */
/* */
/* */
Arg WHOLENUM
WHOLENUM = Strip(WHOLENUM)
COMMAVAR3 = ''
Parse var WHOLENUM COMMAVAR1
COMMAVAR1 = Reverse(COMMAVAR1)
Do while COMMAVAR1 <> ''
Parse var COMMAVAR1 COMMAVAR2 4 COMMAVAR1
If COMMAVAR3 = '' then COMMAVAR3 = COMMAVAR2
Else COMMAVAR3 = COMMAVAR3','COMMAVAR2
End
FORMATTED_WHOLENUM = Reverse(COMMAVAR3)
Return FORMATTED_WHOLENUM
/* rexx */
RDATE:
/* */
/* */
/************************************************/
/* Convert MM DD YYYY , YYYY DDD, or NNNNN to */
/* standard date output that includes the day */
/* of the week and the number of days (NNNNN) */
/* from January 1, 1900. This is not the same */
/* as the Century date! Valid input dates range */
/* from 01/01/1900 through 12/31/2172. */
/* */
/* A parm of "TODAY" can also be passed to */
/* the date conversion routine. */
/* MM DD YYYY can also be specifed as */
/* MM/DD/YYYY or MM-DD-YYYY. */
/* */
/* The output format is always as follows: */
/* MM/DD/YYYY.JJJ NNNNN WEEKDAY */
/* */
/* The above value will be put in the special */
/* REXX variable "RESULT" */
/* example: CALL RDATE TODAY */
/* example: CALL RDATE 1996 300 */
/* example: CALL RDATE 10 26 1996 */
/* example: CALL RDATE 10/26/1996 */
/* example: CALL RDATE 10-26-1996 */
/* example: CALL RDATE 35363 */
/* result: 10/26/1996.300 35363 Saturday */
/************************************************/
arg P1 P2 P3
If Pos('/',P1) <> 0 | Pos('-',P1) <> 0 then do

PX = Translate(P1,' ','/-')
Parse var PX P1 P2 P3
End
JULTBL = '000031059090120151181212243273304334'
DAY.0 = 'Sunday'
DAY.1 = 'Monday'
DAY.2 = 'Tuesday'
DAY.3 = 'Wednesday'
DAY.4 = 'Thursday'
DAY.5 = 'Friday'
DAY.6 = 'Saturday'
Select
When P1 = 'TODAY' then do
P1 = Substr(date('s'),5,2)
call CONVERT_MDY
call THE_END
end
When P2 = '' & P3 = '' then do
call CONVERT_NNNNN
call THE_END
end
When P3 = '' then do
call CONVERT_JDATE
call DOUBLE_CHECK
call THE_END
end
otherwise do
call CONVERT_MDY
call DOUBLE_CHECK
call THE_END
end
end /* end select */
/* say RDATE_VAL; exit 0 */
return RDATE_VAL
/**********************************************/
/* E N D O F M A I N L I N E C O D E */
/**********************************************/
CONVERT_MDY:
if P1<1 | P1>12 then do
say 'Invalid month passed to date routine'
exit 12
end
say 'Invalid day passed to date routine'
exit 12
end
if (P1=4 | P1=6 | P1=9 | P1=11) & P2>30 then do
exit 12
end
if P3<1900 | P3>2172 then do
say 'Invalid year passed to date routine. Must be be 1900-2172'
exit 12
end
BASE = Substr(JULTBL,((P1-1)*3)+1,3)
if (P3//4=0 & P3<>1900 & P3<>2100) then LEAP= 1
else LEAP = 0
if P1 > 2 then BASE = BASE+LEAP
JJJ = BASE + P2
MM = P1
DD = P2
YYYY = P3
return
CONVERT_NNNNN:
if P1<1 | P1>99712 then do
say 'Invalid date passed to date routine. NNNNN must be 1-99712'
exit 12
end
/* Determine YYYY and JJJ */
if P1>365 then P1=P1+1
YEARS_X4=(P1-1)%1461
JJJ=P1-YEARS_X4*1461
if P1 > 73415 then JJJ = JJJ +1
EXTRA_YEARS=(JJJ*3-3)%1096
JJJ=JJJ-(EXTRA_YEARS*1096+2)%3
YYYY=YEARS_X4*4+EXTRA_YEARS+1900
P1 = YYYY ; P2 = JJJ ; call CONVERT_JDATE
CONVERT_JDATE:
MATCH = 'N'
if P1<1900 | P1>2172 then do
say 'Invalid year passed to date routine. Must be be 1900-2172'
exit 12
end
say 'Invalid Julian date passed to date routine'
exit 12
end
if (P1//4=0 & P1<>1900 & P1<>2100) then LEAP= 1
else LEAP = 0
ADJ1 = 0
ADJ2 = 0
Do MM = 1 to 11
VAL1 = Substr(JULTBL,((MM-1)*3)+1,3)
VAL2 = Substr(JULTBL,((MM-1)*3)+4,3)
if MM >=2 then ADJ2 = LEAP
if MM >=3 then ADJ1 = LEAP
if P2 > VAL1+ADJ1 & P2 <= VAL2+ADJ2 then do
DD = P2-VAL1-ADJ1
MATCH = 'Y'
leave
end
end
if MATCH <> 'Y' then do
MM = 12
DD = P2-334-LEAP
end
YYYY = P1
JJJ = P2
return
DOUBLE_CHECK:
if MM = 2 then do
if DD > 28 & LEAP = 0 then do
exit 12
end
if DD > 29 & LEAP = 1 then do
exit 12
end
end
if LEAP = 0 & JJJ > 365 then do
say 'Invalid Julian date passed to date routine'
exit 12
end
return
THE_END:
YR_1900 = YYYY-1900
NNNNN = (YR_1900*365) +(YR_1900+3)%4 + JJJ
if YYYY > 1900 then NNNNN = NNNNN-1
if YYYY > 2100 then NNNNN = NNNNN-1
INDEX = NNNNN//7 /* index to DAY stem */
WEEKDAY = DAY.INDEX
DD = Right(DD,2,'0')
MM = Right(MM,2,'0')
YYYY = Strip(YYYY)
NNNNN = Right(NNNNN,5,'0')
JJJ = Right(JJJ,3,'0')
RDATE_VAL = MM||'/'||DD||'/'||YYYY||'.'||JJJ||' '||NNNNN||' '||WEEKDAY

return
SIG_ALL:
SIGTYPE = Condition('C') /* condition name */
If SIGTYPE = 'SYNTAX' then , /* SYNTAX error ? */
SIGINFO = Errortext(RC) /* rexx error message */
Else SIGINFO = Condition('D') /* condition description */
SIGLINE = Strip(Sourceline(SIGL)) /* error source code */
Say 'SIGNAL -' SIGTYPE 'ERROR:' SIGINFO , /* display the error info */
'on source line number' SIGL':' /* and line number */
Say '"'SIGLINE'"' /* error source code */
"Delstack" /* delete data stack */
Exit 16 /* exit RC=16 */

IPLINFO

Uploaded by

Document Informationclick to expand document information

Copyright:

Available Formats

IPLINFO

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

IPLINFO

Uploaded by

Copyright:

Available Formats

/* REXX */

HEADING: /* Heading sub-routine */

CKWEB: /* Create HTML needed for web page output sub-routine */

COMMON: /* Control blocks needed by multiple routines */

IPL: /* IPL information sub-routine */

VERSION: /* Version information sub-routine */

STOR: /* Storage information sub-routine */

CPU: /* CPU information sub-routine */

IPA: /* IPA information sub-routine */

SYMBOLS: /* System Symbols information sub-routine */

VMAP: /* Virtual Storage Map sub-routine */

If bitand(CVTOSLV3,'02'x) = '02'x then do /* z/OS 1.5 and above? */

RCELVSHRSTRT = RCELVSHRSTRT/1024/1024 /* change to MB */

RCELVHPRSTRT = RCELVHPRSTRT/1024/1024 /* change to MB */

RCELVSHRPAGES = C2d(Storage(D2x(RCE + 584),8)) /* shr pages */

RCELVSHRGBYTES = C2d(Storage(D2x(RCE + 592),8)) /* shr bytes HWM */

Queue ' '

End /* If bitand(CVTOSLV3,'02'x) = '02'x */

If bitand(CVTOSLV5,'08'x) = '08'x then do /* z/OS 1.10 and above */

RCEHVCommonEnd = C2d(Storage(D2x(RCE + 880),8)) /*high virt addr*/

TOTAL_VHCOMN = RCEHVCommonEnd-RCEHVCommonStrt /* total common */

RCEHVCommonStrt = RCEHVCommonStrt/1024/1024 /* chg to MB */

RCEHVCommonEnd = RCEHVCommonEnd/1024/1024 /* chg to MB */

RCEHVCommonPAGES = C2d(Storage(D2x(RCE + 888),8)) /* comn pages */

Queue ' '

LFASize = RCEReconLFASize + RCENonReconLFASize /* LFAREA size*/

If PL = 1 then do /* z/OS 2.1 / pageable1m support */

LFASize = FORMAT_MEMSIZE(LFASize) /* format size */

If PL = 1 then do /* z/OS 2.1 + pageable1m support */

If Bitand(CVTOSLV5,'04'x) = '04'x then do /* z/OS 1.12 and above */

Queue ' '

PAGE: /* Page Data Sets information sub-routine */

SMF: /* SMF Data Set information sub-routine */

SUB: /* Subsystem information sub-routine */

ASID: /* ASVT Usage sub-routine */

LPA: /* LPA List sub-routine */

LNKLST: /* LNKLST sub-routine */

APF: /* APF List sub-routine */

SVC: /* SVC information sub-routine */

If SVCLOCA = IGCERROR_ADDR | , /* this SVC */

Queue ' ' Right(SVCLST,3,' ') '('Right(D2x(SVCLST),2,0)')' ,

Queue ' ' Right(SVCELST,3,' ') '('Right(D2x(SVCELST),2,0)')' ,

FIND_SVC_LOC: /* determine virtual storage location of SVC */

FIND_NUC: /* Find EP address of "ARG" in NUC MAP */

XLATE_NONDISP: /* translate non-display characters to a "." */

STORAGE_GDA_LDA: /* GDA/LDA Storage values sub-routine */

EXTRACT_SYSPARMS: /* Extract IEASYSxx values from the IPA */

BUILD_IPAPDETB: /* Build table for lookup for IPA values */

SPLIT_IPA_PAGE: /* Split up page data set parms to multiple lines */

SORT_IPA: Procedure expose PRMLINE.

BROWSE_ISPF: /* Browse output if ISPF is active */

TODIN = TODIN + 1 /* add 1 to remainder, needed for next */

/* Determine YYYY and DDD */

/* Format prior to result */

TOD_VAL = YYYY'.'DDD HH':'MM':'SS'.'TTT

If Pos('/',P1) <> 0 | Pos('-',P1) <> 0 then do

RDATE_VAL = MM||'/'||DD||'/'||YYYY||'.'||JJJ||' '||NNNNN||' '||WEEKDAY

You might also like

RCEHVCommonEnd = C2d(Storage(D2x(RCE + 880),8)) /high virt addr/