Return to struct.h CVS log

Up to [Research Unix] / researchv9 / jerq / sgs / inc / sdpsrc / hd

Annotation of researchv9/jerq/sgs/inc/sdpsrc/hd/struct.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * static char ID_strcth[] = "@(#) struct.h: 1.1 1/7/82";
        !             3:  */
        !             4: 
        !             5: /*
        !             6:  * Each manager keeps track of information relevant to a particular
        !             7:  * frame. There is one manager for each frame.
        !             8:  *
        !             9:  *     forward, backward: link the managers into a doubly-linked list of
        !            10:  *                        available (e.g., free) page frames
        !            11:  *     frame_pntr:        the address of the start of the
        !            12:  *                        associated frame.
        !            13:  *
        !            14:  * These three fields are initialized by function sdpinit(), and do
        !            15:  * not change.
        !            16:  *
        !            17:  *     page_id:    the itemid of the start of the page
        !            18:  *                 which resides in the associated frame.
        !            19:  *     ref_chng:   a flag which indicates whether or not
        !            20:  *                 the page which resides in the associated frame
        !            21:  *                 has been changed.
        !            22:  *     lock_count: the number of lock calls made on items on the resident
        !            23:  *                 page without a corresponding unlock call being issued
        !            24:  *     partition:  the number of the page-frame partition
        !            25:  *                 to which this manager belongs
        !            26:  *
        !            27:  * The value of these last three members is transient.
        !            28:  */
        !            29: 
        !            30: struct frame_manager {
        !            31:        long    page_id;        /* itemid to start of resident page     */
        !            32:        int     lock_count;     /* number of locks without matching 
        !            33:                                        unlocks                         */
        !            34:        int     forward;        /* forward link to next manager         */
        !            35:        int     backward;       /* backward link to previous manager    */
        !            36:        int     ref_chng;       /* reference/change flag                */
        !            37:        int     partition;      /* page frame partition                 */
        !            38:        char   *frame_pntr;     /* address of associated frame          */
        !            39:        };
        !            40: 
        !            41: typedef struct frame_manager MANAGER;
        !            42: /*eject*/
        !            43: /*
        !            44:  * A structure header_buffer exists for each open address space.
        !            45:  * Each structure contains information which descirbe the status
        !            46:  * of the associated address space.
        !            47:  */
        !            48: 
        !            49: struct header_buffer {
        !            50:        long    maxpage;        /* largest page number allocated        */
        !            51:        long    curpage;        /* page number of current page          */
        !            52:        int     curoffset;      /* offset into current page             */
        !            53:        int     numbfiles;      /* number of files composing space      */
        !            54:        long    filesize[MAXFILES];     /* size (in pages) of files     */
        !            55:        int     filedes[MAXFILES];      /* file descriptors of files    */
        !            56:        };
        !            57: 
        !            58: typedef struct header_buffer HEADER;

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.