LCPBK | Back to Index page

| Prolog Control Block Contents LCPBK DSECT Storage Layout Cross Reference (Contains links to field and bit definitions) |
Programming Interface Information: This information is NOT intended to be used as Programming Interfaces of z/VM.

LCPBK Prolog | Top of page

     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 Control Block Content | Top of page

     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 Storage Layout | Top of page

    *** 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

LCPBK Cross Reference | Top of page

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

This information is based on z/VM 7.2.0 Last updated on 24 Jun 2020 at 09:28:50 EDT.
Copyright IBM Corporation, 1990, 2020