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

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.