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

Types of OPSINFO Functions

• 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 that is returned is two characters whose binary value is the ASID.

• var = OPSINFO('CLOCK')

  Returns the 8-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 a more meaningful format. For example, it returns the value R75 on an IBM 9672-R75, whereas the CPUMODEL value is 77. Where this information is unavailable, the value that is 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 that this function returns is usually the same as that which OPSINFO('CPCMODEL') returns, but it is 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. If the STSI instruction fails to retrieve the required information, 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.

  Note: In AOF Test, this function returns the same result as OPSINFO('CPCMODEL'). If you are out of 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 the result of OPSINFO('CPCMODEL') to determine whether 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 submodel 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, it is not available to be used to execute programs, and it 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 with 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, it is not available to be used to execute programs, and it 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 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. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the EXECNODEID function returns a 15-character string instead of data: *NOT-AVAILABLE*

• var = OPSINFO('EXECPGM')

  Returns the name of the program that is 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 the processing of 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.

• 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 a line that is connected to an NJE system. This variable enables you to specify an installation policy that is based on where a job comes from: for example, to prevent a job that came in from LNE1 from exceeding the output limit. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the INPUTDEV function returns a 15-character string instead of data: *NOT-AVAILABLE*

• 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. OPSINFO('IPLTYPE') returns one of the following values:

  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 that is obtained from the consecutive 4-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. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the JCTUSER function returns a 15-character string instead of data: *NOT-AVAILABLE*

• 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 this 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.

  Note: The last three of the preceding values 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 systems 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 named JES9 but it is a JES2 subsystem, the following values are returned:

  • OPSINFO('JES') = 'JES9'
  • OPSINFO('JESTYPE') = 'JES2'

  Note: The value that is 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 OPSINFO('JOBCLASS') is 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.

  Note: For more information about the use of OPSINFO('JOBID') in a message rule, 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 that is being processed in the z/OS SS09 exit, OPS/REXX returns the job name of the issuer of the WTO that triggered the rule. 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 it 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, it is not available to be used to execute programs, and it 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, it is not available to be used to execute programs, and it 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. One processor has four logical channel subsystems. Each processor can have up to 1024 CHPIDs.

• var = OPSINFO('LEAPSECONDS')

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

  Note: Civil time is occasionally adjusted in 1-second increments to ensure that the difference between a uniform time scale that is defined by atomic clocks does not differ from 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 that is 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 that are 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 following values would be returned to these programs:

  • 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.

  To match products to modules, use the following table:

• 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.

  Note: For more information about the SYSID parameter, see the description 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. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the MSGCLASS function returns a 15-character string instead of data: *NOT-AVAILABLE*

• 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 function enables automation developers to send TSO user messages concerning their jobs. Under some conditions, the NOTIFYID function returns a 15-character string instead of data: *NOT-AVAILABLE*

• 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 that is 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 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. Use this function 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. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the ORIGINNODE function returns a 15-character string instead of data: *NOT-AVAILABLE*

• 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.

  Note: For more information about the PRODUCTNAME parameter, see the description 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 CA OPS/MVS 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 one of the following values:

  INIT

  Indicates that CA OPS/MVS is initializing.

  ACTIVE

  Indicates that CA OPS/MVS is active and processing system events.

  TERM

  Indicates that CA OPS/MVS is terminating.

  Only rules can invoke this function. The PRODUCTSTATUS function 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, then OPSINFO('PROGRAM') returns a null string. In the AOF environment, OPSINFO('PROGRAM') returns ruleset.rule.

• var = OPSINFO('PROGRAMMER')

  Returns the programmer information that is associated with the current address space. In the AOF environment, except when running in a server, the information that is 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 8-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.

  When you use the OPSINFO('RELEASE') function to differentiate between code that may run on multiple versions of CA OPS/MVS, 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('SCHENV')

  Returns the Scheduling Environment Name that is associated with the output of the current address space. If the primary job entry subsystem is not JES2, or JES2 is not active when this function is called, the SCHENV function returns a 15-character string instead of data: *NOT-AVAILABLE*

• var = OPSINFO('SERVICECLASS')

  Returns the WLM service class name, up to a maximum of eight 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. To determine if immediate exit from the rule is required, use the AOF request rule that is called by the SSM subtask to check this value periodically.

  The function returns one of these values:

  YES

  Indicates that 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

  Indicates that the System State Manager is active.

  INACTIVE

  Indicates that the System State Manager is not active.

  NONE

  Indicates that the System State Manager is not being used.

  NOPREREQ

  Indicates that the System State Manager is active but will perform no prerequisite checking.

  PASSIVE

  Indicates that the System State Manager is active but is not monitoring resources.

  *NOT-AVAILABLE*

  Indicates that CA OPS/MVS is not active.

• var = OPSINFO('STATEMANTABLE')

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

  NOPREREQ

  Indicates that the System State Manager is active, but not checking the status of prerequisites for system resources.

  *NOT-AVAILABLE*

  Indicates that CA OPS/MVS 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 SUBMITTER function returns a 15-character data string instead of data: *NOT-AVAILABLE*

• var = OPSINFO('SUBSYS')

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

• var = OPSINFO('SYSCLONE')

  Returns the 1- or 2-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 timezone offset from GMT in seconds. Use this value 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('TZADJUST')
• Returns the timezone offset from GMT as a 16 character zoned hexadecimal string. This value is required by the OPSLOG function TZADJ keyword operand for adjusting system clock times on systems using non-standard z/OS time zone values.

  Note: This value may represent a negative number.

• 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

  Indicates 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

  Indicates that 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('UTC')

  Returns the coordinated universal time (UTC) in yyyy/mm/dd hh:mm:ss format.

• var = OPSINFO('VERSION')

  Returns an 8-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.

  When you use 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 . . .
  

  Note: This function is a synonym for OPSINFO('RELEASE').

• 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).