NAME       : HCPLCPBK
 DESCRIPTION: Limiting CPU Pool system block
              =        =   =           =   =
 DSECT      : LCPBK
 FUNCTION   : This control block holds all of the system level fields
              for the CPU Pooling line item.  This includes the pointers
              to the chain of LIMBKs (1 per CPU Pool defined), the LIMBK
              CHAIN LOCK, and any other fields needed at the system level.
              There is ONE HCPLCPBK per z/VM system.
 LOCATED BY : SYSLCPBK: SYSCM pointer to the LCPBK for the system
              LIMNEXT:  LIMBK chain FORWARD pointer to NEXT LIMBK
              LIMPREV:  LIMBK chain BACKWARD pointer to PREVIOUS LIMBK
 CREATED BY : HCPISR    At initialization of the system.
 DELETED BY : NONE
 REFERENCES : HCPLIMBK: Limiting Control Block for a CPU Pool
 SERIALIZED : HCPISRM only runs during system initialization time so no
              serialization is needed.
              The LIMBK CHAIN LOCK (LCPLLCK) is contained in this
              control block and is used to serialize the content of
              specific LIMBK/VMDBK fields as well as the LIMBK CHAIN
              which consists of the LCPNEXT/LCPPREV/LIMNEXT/LIMPREV
              pointers. When CPU Pooling code needs multiple locks,
              the locks needed *MUST* be obtained in this order to
              prevent a deadlock:
              1. SYSRLOLCK  - Shared/Exclusive defer lock to serialize
              access to the RLOBK list. The RLOBK and
              this lock are only used for VMRELOCATION.
              2. LCPLLCK    - Shared/Exclusive defer lock to serialize
              access to the LIMBK CHAIN as well
              as fields in the VMDBK and LIMBK.
              3. SCHEDULER  - Shared/Exclusive defer lock to serialize
              scheduler tasks as well as fields in the
              VMDBK and LIMBK.
              4. LOCAL CYCLIC LIST - SPIN lock to serialize a user's
              chain of VMDBKs.
 RELOCATION CONSIDERATIONS : None
 COMPATIBILITY AND MIGRATION CONCERNS : All system level fields for CPU Pooling should be put
              in this control block and not HCPSYSCM.
 COMMENTS   : Any part including this COPY file needs to also include
              HCPLKWRD (General Lock Word) copy file to compile
              without an error on LKWRDSIZ.
              The 1/19/2011 version of BICOPY VMSKEL was used to create
              this new control block.

 LCPBK DSECT
Top of page

Hex   Dec Type/Val   Lng Label (dup)    Comments
---- ---- --------- ---- -------------- --------
0000    0 Structure      LCPBK          Limiting CPU Pool system block
0000    0 Dbl-Word     8 LCPLLCK (3)    LKWRD for LIMBK CHAIN LOCK which
                                        serializes: - The LIMBK chain
                                        (LCPNEXT, LCPPREV, LIMNEXT,
                                        LIMPREV) - Fields in the LIMBK -
                                        SET SRM LIMITHARD DEADLINE versus
                                        DEFINE CPUPOOL command
0018   24 Address      4 LCPNEXT        Next (first) LIMBK address The
                                        LIMBK CHAIN is double-linked,
                                        circular, & includes the anchor
                                        (LCPNEXT/LCPPREV). When empty,
                                        LCPNEXT=LCPPREV=ADDR(LCPNEXT).
                                        With 2 LIMBKS, LCPNEXT/LIMNEXT
                                        pointers are followed to get
                                        LCPNEXT->LIMBK1.LIMNEXT->
                                        LIMBK2.LIMNEXT->LCPNEXT.
                                        Serialized by LIMBK CHAIN LOCK
001C   28 Address      4 LCPPREV        Previous (last) LIMBK address The
                                        LIMBK CHAIN is double-linked,
                                        circular, & includes the anchor
                                        (LCPNEXT/LCPPREV). When empty,
                                        LCPNEXT=LCPPREV=ADDR(LCPNEXT).
                                        With 2 LIMBKS, LCPPREV/LIMPREV
                                        pointers are followed to get:
                                        LCPPREV->LIMBK2.LIMNEXT
                                        LIMBK2.LIMPREV->LIMBK1.LIMNEXT
                                        LIMBK1.LIMPREV->LCPNEXT.
                                        Serialized by LIMBK CHAIN LOCK
0020   32 Bitstring    1 LCPCPUAF       CPU Affinity flag byte ON =CPU
                                        Affinity ON OFF=CPU Affinity
                                        SUPPRESSED CPU Affinity is a
                                        concept that only applies to
                                        secondary processors (IFL, zIIP,
                                        zAAP, ICF). CPU pools can only
                                        limit CPUs of type IFL or CP.
                                        Since CP processors are not
                                        secondary processors, a userid's
                                        CPU AFFINITY setting does not
                                        effect what real processors the
                                        work assigned to virtual CP
                                        processors runs on. Thus, only
                                        CPU AFFINITY for IFL engines
                                        matters to the CPU pooling
                                        support and is remembered here.
                                        See HCPCPA's prologue General
                                        Comments for more details on CPU
                                        Affinity. Serialized by SCHEDULER
                                        LOCK
          1... ....      LCPIFL         X'80' IFL engine CPU Affinity
0021   33 Bitstring    1 * (3)          Reserved for IBM use
0024   36 Signed       4 LCPCIFLA       Sequence number of current IFL
                                        engine CPU Affinity toggle.
                                        Serialized by SCHEDULER LOCK
0028   40 Dbl-Word     8 *              Reserved for IBM use
0030   48 Dbl-Word     8 *              Reserved for IBM use
0038   56 Dbl-Word     8 *              Reserved for IBM use
0040   64 Dbl-Word     8 *              Reserved for IBM use
          00000009       LCPSIZE        (*-LCPBK+7)/8 size in double
                                        words
          00000048       LCPBSIZE       LCPSIZE*8 size in bytes

          
*** LCPBK - Limiting CPU Pool system block
*
*     +-------------------------------------------------------+
*   0 |                                                       |
*     =                       LCPLLCK                         =
*     |                                                       |
*     +---------------------------+---------------------------+
*  18 |         LCPNEXT           |         LCPPREV           |
*     +------+--------------------+---------------------------+
*  20 |:CPUAF|////////////////////|         LCPCIFLA          |
*     +------+--------------------+---------------------------+
*  28 |///////////////////////////////////////////////////////|
*     +-------------------------------------------------------+
*  30 |///////////////////////////////////////////////////////|
*     +-------------------------------------------------------+
*  38 |///////////////////////////////////////////////////////|
*     +-------------------------------------------------------+
*  40 |///////////////////////////////////////////////////////|
*     +-------------------------------------------------------+
*  48
*
*** LCPBK - Limiting CPU Pool system block

 
Symbol         Dspl Value
-------------- ---- -----
LCPBSIZE       0040 00000048
LCPCIFLA       0024
LCPCPUAF       0020
LCPIFL         0020 80
LCPLLCK        0000
LCPNEXT        0018
LCPPREV        001C
LCPSIZE        0040 00000009