OPS/REXX Built-in Functions › OPSINFO Function › Types of OPSINFO Functions

Types of OPSINFO Functions

In the following list of OPSINFO functions, functions marked with one asterisk (*) are valid only for JES2 users, and functions marked with two asterisks (**) are valid only for JES3 users. All other functions operate in both JES environments.

• var = OPSINFO('ACCOUNT')

  Returns ACCOUNT information for the current address space. Multiple accounting fields are returned separated by blanks.

• var = OPSINFO('AOFTEST')

  Returns the value ACTIVE when the current REXX code is executing in the AOF Test environment, otherwise returns INACTIVE. Use this function to check whether a rule is executing in AOF Test.

• var = OPSINFO('AMJOBID')

  Returns the job ID in one of the following formats:

  • yyynnnnn where yyy is STC, JOB, or TSU and nnnnn is the JES job ID number; or a zero length string if the job is running SUB=MSTR.
  • ynnnnnnn where y is S (STC), J (JOB), or T (TSU) and nnnnnnn is the JES job ID number; or a zero length string if the job is running SUB=MSTR.

  Note: OPSINFO('JOBID') returns the same information but in a slightly different format.

• var = OPSINFO('ARCHLVL')

  Returns a value indicating the architecture level:

  • 1 indicates ESA/390 architecture
  • 2 indicates z/architecture
• var = OPSINFO('ASID')

  Returns the z/OS Address Space Identifier (ASID) number of the address space in which the CA OPS/MVS program issuing this function call is running. The value returned is two characters whose binary value is the ASID.

• var = OPSINFO('CLOCK')

  Returns the eight-byte binary value result of doing a STORE CLOCK on the CPU at the moment the function is called.

• var = OPSINFO('CPCMODEL')

  Returns a string containing the model number of the central processing complex (CPC) that this program is executing on. This value is related to the value returned by OPSINFO ('CPUMODEL'), but is in more meaningful format. For example, it returns the value R75 on an IBM 9672-R75, whereas the CPUMODEL value is 77. In cases of older processors where this information is unavailable, the value returned is identical to that returned by OPSINFO ('CPUMODEL').

• var = OPSINFO('CPCMODELD')

  Returns a string containing the dynamic model number of the central processing complex (CPC) on which this program is executing. The value returned by this function is usually the same as that returned by OPSINFO('CPCMODEL'), but it will be different in the following cases:

  • A dynamic processor upgrade has been performed and the CPC has not been IMLed.
  • The processor does not support the STSI instruction. In this case, this function returns the string NOSTSI.
  • The STSI instruction failed to retrieve the required information. In this case, this function returns the string STSIFL. This should not occur. If it does, then report it to CA OPS/MVS customer support and request assistance.
  • The CA OPS/MVS subsystem is not active. In this case, this function returns the string SS_N/A.

  Notes:

  • In AOF Test, this function always returns the same result as OPSINFO('CPCMODEL')
  • When not in AOF Test and the result is not one of the special strings NOSTSI, STSIFL, or SS_N/A, you can compare the result of this function with that of OPSINFO('CPCMODEL') to determine if a dynamic processor upgrade has been performed
• var = OPSINFO('CPSZAAPS')

  Returns the count of zAAPs (zSeries Application Assist Processors) currently online.

• var = OPSINFO('CPSZIIPS')

  Returns the count of zIIPs (zSeries Integrated Information Processors) currently online.

• var = OPSINFO('CPSREGULAR')

  Returns the count of regular central processors (CPs) currently online.

• var = OPSINFO('CPUID')

  Returns the six-character CPU identifier of the CPU where the OPS/REXX program or rule is running.

• var = OPSINFO('CPUMODEL')

  Returns the two-character CPU sub-model code of the CPU where the OPS/REXX program or rule is running. When running under VM this function returns the value FF.

• var = OPSINFO('CPUSCONFIG')

  Returns the configured CPU count. This value represents the number of CPUs that are in the configured state. A CPU is in the configured state when it is in the configuration and available for executing programs.

• var = OPSINFO('CPUSONLINE')

  Returns the count of regular CPs and zAAPs (zSeries Application Assist Processors) and zIIPs (zSeries Integrated Information Processors) currently online.

• var = OPSINFO('CPUSRESERVED')

  Returns the reserved CPU count. This value represents the number of CPUs that are in the reserved state. A CPU is in the reserved state when it is in the configuration, is not available to be used to execute programs, and cannot be made available by issuing instructions to place it in the configured state.

  Note: It may be possible to place a reserved CPU in the standby or configured state by means of manual actions.

• var = OPSINFO('CPUSSTANDBY')

  Returns the standby CPU count. This value represents the number of CPUs that are in the standby state. A CPU is in the standby state when it is in the configuration, is not available to be used to execute programs, and can be made available by issuing instructions to place it in the configured state.

• var = OPSINFO('CPUSTOTAL')

  Returns the total basic CPU count. This value represents the total number of CPUs in the configuration. This number includes all CPUs in the configured state, the standby state, or the reserved state.

  Note: CPUSTOTAL = CPUSCONFIG + CPUSSTANDBY + CPUSRESERVED

• var = OPSINFO('CPUTYPE')

  Returns the four-character CPU type (for instance, 9672) of the CPU where the OPS/REXX program or rule is running.

• var = OPSINFO('DFPVERSION')

  Returns the level of DFP running on the system where the OPSINFO function call was executed; in the form r.r, where r.r is the release number (for example, 3.3).

• var = OPSINFO('DFSMSVERSION')

  Returns the version of DFSMS in the form r.r, (for example, 1.5). If DFSMS is not installed, this OPSINFO function returns the string N/A. If you have installed DFSMS, the OPSINFO('DFPVERSION') function always returns the same value.

• var = OPSINFO('EVENTTYPE')

  Returns the type of event the rule is processing, such as MSG or DOM. This function is intended for use in external OPS/REXX functions that may be called by more than one kind of rule.

  When you use this function outside the rule environment (for example, in an OPS/REXX program in a server), it always returns the string NONE.

  This function returns one of these values:

  • API
  • ARM
  • CMD
  • DIS
  • DOM
  • ENA
  • EOJ
  • EOM
  • EOS
  • GLV
  • MSG
  • OMG
  • REQ
  • SCR
  • SEC
  • TLM
  • TOD
  • USS
  • NONE
• var = OPSINFO('EXECNODEID')

  Returns the JES2 execution node ID. Under some conditions, the EXECNODEID function returns a 15-character string *NOT-AVAILABLE* instead of data. If the primary job entry subsystem is not JES2 or JES2 is not active when this function is called, the string NOT-AVAILABLE is returned.

• var = OPSINFO('EXECPGM')

  Returns the name of the program specified on the EXEC PGM=progname JCL statement for the current step.

• var = OPSINFO('EXITTYPE')

  Returns the name of the exit in which the AOF captured the event that triggered this rule. This function returns one of these values:

  • CA7
  • CICS
  • DSN
  • ERR
  • IMS
  • JES3
  • MVS
  • NONE
  • OMG
  • TRAC
  • NIP
  • CNSV

  A common use of OPSINFO('EXITTYPE') is to prevent processing a single message more than once in the IMS or JES3 environments.

• var = OPSINFO('GRSMODE')

  Returns a string indicating the mode in which Global Resource Serialization (GRS) is executing. This function returns one of these values:

  • NONE-Global GRS is not active
  • RING-Global GRS is in Ring mode
  • STAR-Global GRS is in Star mode
  • UNKN-Unable to determine the mode (should not occur)
• var = OPSINFO('HARDWARENAME')

  Returns the name of the processor configuration.

• var = OPSINFO('IMSID')

  Returns the IMS identifier (IMSID) associated with the address space where the OPS/REXX program is running. NONE is returned if the address space is not an IMS Control Region, a DLISAS Region, a DBRC address space, a Message Processing Region, or a Batch Message Processing Region.

  IMSID is of greatest interest to AOF message rules. For example, canceling an IMS BMP is dangerous because doing so can bring down all of IMS. A rule can use the OPSINFO function to:

  • Determine if the job issuing a z/OS message that usually calls for cancellation is an IMS-dependent region
  • Take some other action for these regions

  Note: This function is available only if the IOF is licensed, installed, and active at your site. If the IOF is not installed or is inactive, this function always returns the string NONE.

• var = OPSINFO('IMSTYPE')

  The type of IMS region for the address space in which the current REXX program or rule is running. The possibilities are:

  • NON-The address space where the current REXX program or rule is running was not associated with any IMS Control Region
  • CTL-The address space where the current REXX program or rule is running was an IMS Control Region
  • DEP-The address space where the current REXX program or rule is running was an IMS MPP region
  • BCH-The address space where the current REXX program or rule is running was an IMS BMP region

  OPSINFO cannot determine if the address space is using batch DL/I facilities independent of any Control Region (even if using database- or block-level sharing through DBRC/IRLM).

  Note: This function is available only if the IOF is licensed, installed, and active at your site. If the IOF is not installed or is inactive, this function always returns the three-character string NON.

• var = OPSINFO('INPUTDEV')

  Returns the name of the input device for a job. The input device can be an internal reader, a card reader, a remote workstation, or even a line connected to an NJE system. This variable enables you to specify installation policy based on where a job comes from: for example, to prevent a job that came in from LNE1 from exceeding the output limit. Under some conditions, the INPUTDEV function returns a 15-character string *NOT-AVAILABLE* instead of data. If the primary job entry subsystem is not JES2 or JES2 is not active when this function is called, the string NOT-AVAILABLE is returned.

• var = OPSINFO('IPLDATE')

  Returns the date when z/OS was last IPLed (for example, 20030428 for April 28, 2003), in standard OPS/REXX date format S.

• var = OPSINFO('IPLDEVICE')

  Returns the device number of the DASD volume from which the last IPL was performed, (for example, 9C01). This device number can have four hexadecimal digits.

• var = OPSINFO('IPLTIME')

  Returns the time when z/OS was last IPLed (for example, 13:30:10 for 1:30 P.M. plus 10 seconds), in standard OPS/REXX time format N.

• var = OPSINFO('IPLTYPE')

  Returns a value representing how the system was last IPLed. This value is one of the following:

  • CLPA-The system was IPLed using the CLPA option
  • CVIO-The system was IPLed using the CVIO option
  • WARM-The system was warm started (IPLed without a complete shutdown)
• var = OPSINFO('IPLVOLSER')

  Returns the volume serial of the DASD volume from which the last IPL was performed, (for example, SYSRES).

• var = OPSINFO('ISPF')

  Returns the value ACTIVE when ISPF is active in the current environment otherwise returns NOT ACTIVE. Use this function to check whether ISPF services can be used in the current OPS/REXX program.

• var = OPSINFO('JCTUSER')

  Returns a 64-byte hexadecimal string containing data obtained from the consecutive four byte fields in the JES2 JCT ($JCT), starting at fields JCTUSER0 through JCTUSERF. This information is available to the installation and can be accessed in a CA OPS/MVS rule. Under some conditions, the JCTUSER function returns a 15-character string *NOT-AVAILABLE* instead of data. If the primary job entry subsystem is not JES2 or JES2 is not active when this function is called, the string NOT-AVAILABLE is returned.

• var = OPSINFO('JES')

  Returns the name of the Primary Job Entry Subsystem. Typically, this value is either JES2 or JES3, but it can be any subsystem name that you have assigned to the primary JES (JES5, JES9, and so on). Contrast with the description of OPSINFO('JESTYPE').

• var = OPSINFO('JES3GBLNAME')

  Returns one of these values:

  • The JES3 global processor name if JES3 is the primary job entry subsystem
  • NULL if JES3 is not the primary job entry subsystem or JES3 is not active in the system
• var = OPSINFO('JES3SPOOL')

  Available only in rules, the JES3SPOOL keyword obtains information about the prefix character JES3 is placing in front of each console message.

  The OPSINFO('JES3SPOOL') function returns one of these values:

  • N/A if you use the function from in the AOF test environment
  • NONE if this is a JES3 global system and no spool space problems exist
  • NOTJES3 if the host system is not running JES3 or if the ignore JES3 flag is set
  • JES3DOWN if JES3 has failed or if JES3 is not started
  • JES3LOCAL if the current system is a JES3 local
  • MARGINALSPACE if JES3 spool space is marginal
  • MINIMALBUFFERS if JES3 JSAM buffers are minimal
  • MINIMALSPACE if JES3 spool space is minimal

  The last three conditions listed above correspond to separate message prefix characters.

• var = OPSINFO('JESSYSNAME')

  Returns the ID of the JES on which CA OPS/MVS is active. For systems running JES2, this value is the SMF ID of the current z/OS system. For those running JES3, it is the MP name.

• var = OPSINFO('JESTYPE')

  Returns a value that indicates whether the primary JES subsystem is a JES2 or JES3 subsystem. The returned value is always either JES2 or JES3, regardless of the actual subsystem name. For example, if the primary JES is called JES9 but it is a JES2 subsystem, the following values are returned:

  OPSINFO('JES') = 'JES9'

  OPSINFO('JESTYPE') = 'JES2'

  Note: The value returned by OPSINFO('JESTYPE') may not be valid when the primary JES is not active in the system (for example, immediately following an IPL).

• var = OPSINFO('JOBCLASS')

  Returns the current job class. If used in a JES3 environment, this function returns the eight-character JES3 job class.

• var = OPSINFO('JOBID')

  Returns the JES job identifier of the current home address space. This variable has one of the following formats:

  • xnnnnn, where x is J (JOB), T (TSU), or S (STC) and nnnnn is the job number.
  • xnnnnnnn, where x is J (JOB), T (TSU), or S (STC) and nnnnnnn is the job number.

  If you are using this function in a message rule, then for more information see the description of the MSG.JOBID variable in the chapter “Coding Each AOF Rule Type” in the AOF Rules User Guide.

• var = OPSINFO('JOBNAME')

  Returns the JOBNAME associated with the address space where the OPS/REXX program is running. For a message rule being processed in the z/OS SS09 exit, OPS/REXX returns the job name of the issuer of the WTO that triggered the rule. This means that for a reissued message that originated on another system the job name is the one that actually issued the WTO on the originating system.

• var = OPSINFO('LCPUSCONFIG')

  Returns the LPAR configured CPU count. This value represents the number of logical CPUs for this level-2 configuration that are in the configured state. A logical CPU is in the configured state when it is in the level-2 configuration and is available to be used to execute programs.

• var = OPSINFO('LCPUSRESERVED')

  Returns the LPAR reserved CPU count. This value represents the number of CPUs for this level-2 configuration that are in the reserved state. A logical CPU is in the reserved state when it is in the level-2 configuration, is not available to be used to execute programs, and cannot be made available by issuing instructions to place it in the configured state. (It may be possible to place the reserved CPU in the standby or configured state through manual actions.)

• var = OPSINFO('LCPUSSTANDBY')

  Returns the LPAR standby CPU count. This value represents the number of logical CPUs for this level-2 configuration that are in the standby state. A logical CPU is in the standby state when it is in the level-2 configuration, is not available to be used to execute programs, and can be made available by issuing instructions to place it in the configured state.

• var = OPSINFO('LCPUSTOTAL')

  Returns the total LPAR CPU count. This value represents the total number of logical CPUs that are provided for this level-2 configuration. This number includes all of the logical CPUs that are in the configured state, the standby state, or the reserved state.

  Note: LCPUSTOTAL = LCPUSCONFIG + LCPUSSTANDBY + LCPUSRESERVED

• var = OPSINFO('LCSSID')

  Returns the logical channel subsystem ID as a hexadecimal number. There are four logical channel subsystems in one processor. Each processor can have up to 1024 CHPIDs

• var = OPSINFO('LEAPSECONDS')

  Returns the leap seconds value in seconds. Use this value in conjunction with the OPSINFO('TIMEZONE') value to convert a GMT time to local time.

  Note: Civil time is occasionally adjusted by one second increments to ensure that the difference between a uniform time scale defined by atomic clocks does not differ from the Earth's rotational time by more than 0.9 seconds. Coordinated Universal Time (UTC), an atomic time, is the basis for civil time.

• var = OPSINFO('LOADPARM')

  Returns the eight-character IPL Load Parameter string specified on the service console when the system was last IPLed. For older versions of z/OS, OPS/REXX returns a zero length string.

• var = OPSINFO('LOCMSTCONSNM')

  Returns the first console name that has master authority on the local system. If there is no console that has master authority on the local system, the function returns the name of the sysplex master console. When a no consoles condition exists in the system, this function returns a null string.

• var = OPSINFO('LPARNAME')

  Returns the LPAR name of the processor configuration. Returns a null string if not in LPAR mode.

• var = OPSINFO('LPARNUM')

  Returns the LPAR number as a hexadecimal number. This number distinguishes the configuration from all other level-2 configurations provided by the same LPAR hypervisor.

• var = OPSINFO('MAINPGM')

  Returns the REXX program name or the ruleset.rulename of the rule that invoked the currently executing REXX program. When the main program or rule is still executing, the returned value is the same as the value of OPSINFO('PROGRAM'). For example, suppose that program A calls program B, which, in turn, calls program C. The values returned to these programs would be as follows:

  • If invoked from program A, both the OPSINFO('PROGRAM') and OPSINFO('MAINPGM') functions return the value A
  • If invoked from program B, the OPSINFO('PROGRAM') function returns the value B and OPSINFO('MAINPGM'), the value A
  • If invoked from program C, the OPSINFO('PROGRAM') function returns the value C and OPSINFO('MAINPGM'), the value A
• var = OPSINFO('MAINPRM')

  Returns the character string that was passed to CA OPS/MVS from the PARM field on its EXEC card when CA OPS/MVS was started. This string can contain up to 100 characters.

• var = OPSINFO('MAXEDQ')

  Returns the maximum number of lines that can be placed in the REXX External Data Queue (EDQ) at any one time for the current OPS/REXX program or rule (for example, 3000).

• var = OPSINFO('MODULE')

  Returns the name of the module that triggered the AOF event. For example, in a message rule it returns the name of the module (program) that issued the WTO. When used in an OPS/REXX program running in a TSO address space or in a server it returns the name of a CA OPS/MVS module.

  Use the following table to match products to modules:

• var = OPSINFO('MSFDEFAULTSYS')

  Returns the string that contains the default system setting for the current OPS/REXX program. The current default system is set through the ADDRESS OPSCTL MSF DEFAULT SYSTEM(xxxx) host command.

• var = OPSINFO('MSFID')

  Returns the value of the SYSID parameter. For details, see the description of the SYSID parameter in the Parameter Reference.

• var = OPSINFO('MSGCLASS')

  Returns the message class of a job. You can use it to determine output requirements for various printers. Under some conditions, the MSGCLASS function returns a 15-character string *NOT-AVAILABLE* instead of data. If the primary job entry subsystem is not JES2 or JES2 is not active when this function is called, the string NOT-AVAILABLE is returned.

• var = OPSINFO('MSTCONSNM')

  Returns the name of the current MCS master console. When a no consoles condition exists in the system, this function returns a null string.

• var = OPSINFO('MVSVERSION')

  Returns the level of z/OS on which the OPSINFO function call was executed in the form version.release.modification level.

• var = OPSINFO('NOTIFYID')

  Returns the TSO user identifier who is notified when the job completes. This enables automation developers to send TSO user messages concerning their jobs. Under some conditions, the NOTIFYID function returns a 15-character string *NOT-AVAILABLE* instead of data.

• var = OPSINFO('OMVS')

  Returns the current status of the OMVS kernel ('READY' or 'NOT READY').

• var = OPSINFO('OPSLOGMSGNUM')

  Returns a string containing the OPSLOG message number associated with the current event. The result string always contains zeros when used in a non-AOF rule environment. This function is useful when used in conjunction with the OPSLOG( ) OPS/REXX function.

  The result string contains zeros under the following conditions:

  • When called in the non-AOF rule environment
  • When the event type is not being recorded in OPSLOG, for example, a TOD rule and the BROWSETOD parameter is set to NO
  • An MSG rule for which NOOPSLOG is specified
• var = OPSINFO('ORIGINNODE')

  Returns the originating node of a job. You can use it to implement a security policy for your system, or (in combination with the Multi-System Facility) to inform users about the status of their jobs. Under some conditions, the ORIGINNODE function returns a 15-character string *NOT-AVAILABLE* instead of data. If the primary job entry subsystem is not JES2 or JES2 is not active when this function is called, the string NOT-AVAILABLE is returned.

• var = OPSINFO('PGN')

  Returns the Performance Group Number (PGN) of the currently executing address space. This value is always 0 when the system is running in GOAL mode.

• var = OPSINFO('PRODUCT')

  Returns the value of the PRODUCTNAME parameter. For details, see the description of the PRODUCTNAME parameter in the Parameter Reference.

• var = OPSINFO('PRODUCTSTARTS')

  Returns the number of times that the current CA OPS/MVS subsystem has been started since the last time an IPL of z/OS occurred, or 0 if the subsystem has not been started since the last IPL.

  When used in an OPS/REXX program, this function returns a valid value even if the CA OPS/MVS subsystem being queried is inactive.

  Note: The only time that you can absolutely infer that the CA OPS/MVS product is down from using this function is if it returns 0. If it returns any other value, CA OPS/MVS could be either up or down. For example, a value of 1 could mean that it is either up or down but that it has been started once since the last IPL. To determine if a particular product subsystem is active, check if the RC value set by this command is 0:

  ADDRESS AOF “SUBSYS ssid”
  

• var = OPSINFO('PRODUCTSTATUS')

  Returns the one of the following values:

  • INIT-CA OPS/MVS is initializing
  • ACTIVE-CA OPS/MVS is active and processing system events
  • TERM-CA OPS/MVS is terminating

  Only rules can invoke this function. It returns a null string when a REXX program tries to invoke it. Typically, you might use this function:

  • In the initialization section of a rule, to determine if this is the CA OPS/MVS initial startup
  • In the termination section of a rule, to determine if CA OPS/MVS is terminating
• var = OPSINFO('PRODUCTSTCNAME')

  Returns the name of the CA OPS/MVS started task or job, or INACTIVE if the product is not active.

• var = OPSINFO('PROGRAM')

  In any environment other than a rule running under the CA OPS/MVS Automated Operations Facility (AOF), OPSINFO('PROGRAM') returns the name of the member from which OPS/REXX read the REXX program. If the OPS/REXX program was run from a sequential data set, which is rare, then OPSINFO('PROGRAM') returns a null string. In the AOF environment, OPSINFO('PROGRAM') returns ruleset.rule.

• var = OPSINFO('PROGRAMMER')

  Returns the programmer information associated with the current address space. In the AOF environment, except when running in a server, the information returned is for the address space that triggered the AOF event.

• var = OPSINFO('REALSTORAGE')

  Returns the size, in kilobytes, of the actual real storage online.

• var = OPSINFO('RELEASE')

  (Synonym for OPSINFO ('VERSION'). Returns an eight-byte string that provides the release and service pack number of the CA OPS/MVS product. The format of this string is rr.rr where rr.rr is the release number.

  Thus, when using the OPSINFO('RELEASE') function to differentiate between code that may run on multiple versions of the CA OPS/MVS product, take into account that the modification level changes with each maintenance tape.

  For example, to check for code that can run only with r11.5, use this function:

  if SUBSTR(OPSINFO(“RELEASE”),1,6)==”11.06.” then . . .
  

  To check for code that can run with r11.6 or higher levels, use this function:

  if SUBSTR(OPSINFO(“RELEASE”),1,6)>=”11.06.” then . . .
  

• var = OPSINFO('ROOM')

  Returns the room number associated with the output of the current address space. Under some conditions, the ROOM function returns a 15-character string *NOT-AVAILABLE* instead of data. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the string NOT-AVAILABLE is returned.

• var = OPSINFO('SERVICECLASS')

  Returns the WLM service class name, up to a maximum of 8 characters. If the name does not exist, then N/A is returned.

• var = OPSINFO('SMFID')

  Returns the SMF identifier that your site has assigned to the z/OS image on which CA OPS/MVS is running. z/OS gets this value at IPL time from the appropriate SMFPRMnn member of the Logical Parmlib Concatenation.

• var = OPSINFO('SSMSUBSTOP')

  Returns a value indicating whether the SSM subtask has been requested to terminate. This value should be checked periodically by the AOF request rule called by the SSM subtask to determine if immediate exit from the rule is required.

  The function returns one of these values:

  • YES - The SSM subtask must terminate.
  • NO - The SSM subtask has no pending request to terminate.
  • N/A - This function is not applicable when executed outside of the CA OPS/MVS address space.
• var = OPSINFO('STATEMANSTATUS')

  Returns the current status of the System State Manager task. Possible values are:

  • ACTIVE-System State Manager is active.
  • INACTIVE-System State Manager is not active.
  • NONE-System State Manager is not being used.
  • NOPREREQ-Same as ACTIVE, but will not do any prerequisite checking.
  • PASSIVE-System State Manager is active but is not monitoring resources.
  • *NOT-AVAILABLE*-The CA OPS/MVS product is not active.
• var = OPSINFO('STATEMANTABLE')

  Returns the name of the relational table that System State Manager is currently using or would use if it were active. Possible values are:

  • NOPREREQ-System State Manager is active, but not checking the status of prerequisites for system resources.
  • *NOT-AVAILABLE*-The CA OPS/MVS product is not active.
• var = OPSINFO('STEPNAME')

  Returns the stepname or alternate task ID of the current address space. For example, if you issue the command S CICS.CICSA, the stepname for that address space is CICSA.

• var = OPSINFO('SUBMITTER')

  Returns the user ID that submitted the current job. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the string NOT-AVAILABLE is returned.

• var = OPSINFO('SUBSYS')

  Returns the four-character z/OS subsystem name that CA OPS/MVS is using. The CA OPS/MVS product obtains this value from the first four characters of the PARM field on the EXEC statement in the JCL procedure used for CA OPS/MVS. The default subsystem name is OPSS.

• var = OPSINFO('SYSCLONE')

  Returns the one- or two-byte shorthand notation for the system name from the IEASYMxx member in the Logical Parmlib Concatenation.

• var = OPSINFO('SYSNAME')

  Returns the system name. Global Resource Serialization (GRS) uses this name to identify different systems in a GRS complex/sysplex. z/OS gets this value at IPL time from the SYSNAME parameter in the IEASYSxx member in the Logical Parmlib Concatenation.

• var = OPSINFO('SYSOPSYS')

  Returns a string containing the z/OS name, version, release, modification level, and FMID. For example, on a z/OS V1R5 system, the following string is returned:

  z/OS 01.05.00 HBB7708
  

• var = OPSINFO('SYSPLEX')

  Returns the z/OS sysplex name from the COUPLExx or LOADxx members in the Logical Parmlib Concatenation.

• var = OPSINFO('TMP')

  Returns the value ACTIVE when TMP is active in the current environment, otherwise returns NOT ACTIVE. Use this function to check whether TSO services can be used in the current OPS/REXX program.

• var = OPSINFO('TIMEZONE')

  Returns the time zone offset from GMT in seconds. Use this value in conjunction with the OPSINFO('LEAPSECONDS') value to convert a GMT time to local time.

  Note: This value may be a negative number.

• var = OPSINFO('TSOEVERSION')

  Returns the TSO/E release level in the form v.rr.m (for example, 2.06.0). If TSO/E is not installed, this function returns the value N/A.

• var = OPSINFO('USSEGID')

  Returns the effective numeric USS group ID. An effective group ID may be different from the real group ID of the user that created the process. Effective group ID is the group ID used for security checks. Authorized programs are allowed to change their group ID when required. If this ID is unavailable or undefined, this function returns the value N/A.

• var = OPSINFO('USSEUID')

  Returns the effective numeric USS user ID. An effective user ID may be different from the real user ID of the user that created the process. Effective user ID is the group ID used for security checks. Authorized programs are allowed to change their user ID when required. If this ID is unavailable or undefined, this function returns the value N/A.

• var = OPSINFO('USSGID')

  Returns the real numeric USS group ID. The real numeric USS group ID is the original group ID of the user that created the process. If this ID is unavailable or undefined, this function returns the value N/A.

• var = OPSINFO('USSPGID')

  Returns the numeric process USS group ID. The process group ID is the group ID of the main process that created the current process. If this ID is unavailable or undefined, this function returns the value N/A.

• var = OPSINFO('USSPID')

  Returns the UNIX System Services process ID number (PID), in decimal format, for the current z/OS task. The primary use of this function it to capture the PID from long‑running USS processes that issue messages resulting in AOF message events. Possible values are:

  • nnnnnnnnnn-The process ID number of the current z/OS task.

    Important! This number is not the same as the PID of the parent process when UNIX services fork or spawn are used to issue a message. These UNIX services may generate a short-term process resulting in a message that triggers an AOF message event.

  • N/A-No process ID exists for the current task.
• var = OPSINFO('USSPPID')

  Returns the parent process USS ID for the current z/OS task. The parent process ID is the process ID of the process that created the current process. If this ID is unavailable or undefined, this function returns the value N/A.

• var = OPSINFO('USSUID')

  Returns the USS real user ID for the current z/OS task. The real USS user ID is the original user ID of the user that created the current process. If this ID is unavailable or undefined, this function returns the value N/A.

• var = OPSINFO('VERSION')

  (Synonym for OPSINFO('RELEASE'). Returns an eight-byte string that provides the release number of the product. The format of this string is rr.rr, where rr.rr is the release number.

  Thus, when using the OPSINFO('VERSION') function to differentiate between code that may run on multiple versions, take into account that the modification level changes with each maintenance tape.

  For example, to check for code that can run only with r11.5, use this function:

  if SUBSTR(OPSINFO(“VERSION”),1,6)==”11.05.” then . . .
  

  To check for code that can run with r11.5 or higher levels, use this function:

  if SUBSTR(OPSINFO(“VERSION”),1,6)>=”11.05.” then . . .
  

• var = OPSINFO('VMUSERID')

  Returns the VM user ID of the virtual machine on which this z/OS image is a guest. Returns a null string if z/OS is not running under VM.

• var = OPSINFO(WSSIZE')

  Returns the size in bytes of the REXX work space for the current OPS/REXX program or rule. The REXX work space is used to contain REXX variables (for example, 1572864).