Return to accbuf.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / iutil

Annotation of 43BSD/ingres/source/iutil/accbuf.c, revision 1.1

1.1     ! root        1: # include      <ingres.h>
        !             2: # include      <access.h>
        !             3: # include      <aux.h>
        !             4: # include      <lock.h>
        !             5: # include      <opsys.h>
        !             6: # include      <sccs.h>
        !             7: 
        !             8: SCCSID(@(#)accbuf.c    8.1     12/31/84)
        !             9: 
        !            10: 
        !            11: /*
        !            12: **     access method buffers and other data areas for buffer maintenance
        !            13: */
        !            14: 
        !            15: struct accbuf  Acc_buf[NACCBUFS];      /* the buffers */
        !            16: struct accbuf  *Acc_head;              /* head of usage list */
        !            17: struct accbuf  *Acc_tail;              /* tail of usage list */
        !            18: struct lockreq Lock;
        !            19: 
        !            20: /*
        !            21: **     structs for admin file data
        !            22: */
        !            23: 
        !            24: struct admin   Admin;
        !            25: 
        !            26: /*
        !            27: **     global flag indicating if access methods
        !            28: **     have been initialized.
        !            29: */
        !            30: 
        !            31: int            Acc_init        =       FALSE;
        !            32: 
        !            33: char           Acclock;                /* locks enabled flag */
        !            34: int            Alockdes;               /* file descriptor for lock device*/
        !            35: int            Lockrel;                /* lock relations flag*/
        !            36: /*
        !            37: **     Flush the indicated page and reset all
        !            38: **     important information including the name
        !            39: **
        !            40: **     Trace Flags:
        !            41: **             20.0,1
        !            42: */
        !            43: 
        !            44: resetacc(buf)
        !            45: struct accbuf  *buf;
        !            46: {
        !            47:        register struct accbuf  *b;
        !            48:        register int            i;
        !            49: 
        !            50:        b = buf;
        !            51:        if (b == 0)
        !            52:                b = Acc_head;
        !            53: #      ifdef xATR3
        !            54:        if (tTf(20, 0))
        !            55:        {
        !            56:                printf("RESETACC: %x=", b);
        !            57:                dumptid((TID *) &b->rel_tupid);
        !            58:        }
        !            59: #      endif
        !            60: 
        !            61:        i = pageflush(b);       /* write the page if necessary */
        !            62:        b->rel_tupid = -1;
        !            63:        b->filedesc = -1;
        !            64:        b->thispage = -1;
        !            65:        b->bufstatus = 0;
        !            66:        return (i);
        !            67: }
        !            68: /*
        !            69: **     initialize access method data areas
        !            70: **
        !            71: **     Trace Flags:
        !            72: **             20.2,3
        !            73: */
        !            74: 
        !            75: acc_init()
        !            76: {
        !            77:        register struct accbuf  *last;
        !            78:        register struct accbuf  *b;
        !            79:        struct stat             stbuf;
        !            80:        extern int              errno;
        !            81: 
        !            82: #      ifdef xATR3
        !            83:        if (tTf(20, 2))
        !            84:                printf("ACC_INIT=%d\n", Acc_init);
        !            85: #      endif
        !            86: 
        !            87:        if (Acc_init)
        !            88:                return;         /* already initialized */
        !            89:        last = 0;
        !            90:        for (b = Acc_buf; b < &Acc_buf[NACCBUFS]; )
        !            91:        {
        !            92:                resetacc(b);
        !            93:                b->modb = last;
        !            94:                last = b;
        !            95:                b++;
        !            96:                last->modf = b;
        !            97:        }
        !            98:        last->modf = 0;
        !            99:        Acc_head = Acc_buf;
        !           100:        Acc_tail = last;
        !           101: 
        !           102:        /* get the admin file */
        !           103:        readadmin();
        !           104: 
        !           105:        /*
        !           106:        ** Set up locking information. If the database has concurrency
        !           107:        ** control then Lockrel = TRUE and the concurrency device will
        !           108:        ** be opened for writing. If there is no concurrency for the
        !           109:        ** data base or if the lock device isn't installed, then Alockdes
        !           110:        ** = -1 and no locking will (or can) occure.
        !           111:        */
        !           112:        Lockrel = (Admin.adhdr.adflags & A_DBCONCUR) != 0;
        !           113:        if (Lockrel && Alockdes < 0)
        !           114:                Alockdes = start_up_lock_driver();
        !           115:        errno = 0;      /* clear in case /dev/lock isn't available */
        !           116:        Acclock = TRUE;
        !           117:        stat(".", &stbuf);
        !           118:        bmove((char *) &stbuf, (char *) Lock.dbnode, 4);
        !           119: 
        !           120:        Acc_init = TRUE;
        !           121: }
        !           122: /*
        !           123: **     place buffer at top of LRU list
        !           124: */
        !           125: 
        !           126: top_acc(buf)
        !           127: struct accbuf  *buf;
        !           128: {
        !           129:        register struct accbuf  *b;
        !           130: 
        !           131:        b = buf;
        !           132: 
        !           133:        if (b == Acc_head)
        !           134:                return (0);
        !           135:        if (b == Acc_tail)
        !           136:                Acc_tail = b->modb;
        !           137:        else
        !           138:                b->modf->modb = b->modb;
        !           139:        b->modb->modf = b->modf;
        !           140:        Acc_head->modb = b;
        !           141:        b->modf = Acc_head;
        !           142:        Acc_head = b;
        !           143:        b->modb = 0;
        !           144:        return (0);
        !           145: }
        !           146: /*
        !           147: ** Flush_rel -- flush all pages associated with the relation
        !           148: **     described by the descriptor. If resetflag is TRUE,
        !           149: **     then the buffers are reset so the pages will not be
        !           150: **     found on subsequent calls to find_page().
        !           151: **
        !           152: **     Returns "or'ed" result from calls to pageflush.
        !           153: **
        !           154: **     Trace Flags:
        !           155: **             20.4-5
        !           156: */
        !           157: 
        !           158: flush_rel(d, resetflag)
        !           159: register DESC  *d;
        !           160: int            resetflag;
        !           161: {
        !           162:        register struct accbuf  *b;
        !           163:        register int            i;
        !           164: 
        !           165: #      ifdef xATR3
        !           166:        if (tTf(20, 4))
        !           167:                printf("flush_rel: rel=%.14s, reset=%d\n", d->reldum.relid, resetflag);
        !           168: #      endif
        !           169: 
        !           170:        i = 0;
        !           171:        for (b = Acc_head; b != NULL; b = b->modf)
        !           172:        {
        !           173:                if (d->reltid.ltid == b->rel_tupid)
        !           174:                {
        !           175:                        if (resetflag)
        !           176:                                i |= resetacc(b);
        !           177:                        else
        !           178:                                i |= pageflush(b);
        !           179:                }
        !           180:        }
        !           181: 
        !           182:        return (i);
        !           183: }
        !           184: /*
        !           185: **     CHOOSE_BUF -- Try to find an empty buffer for assignment.
        !           186: **             If there is no empty buffer, pick the last buffer
        !           187: **             in the LRU queue and make sure it is flushed.
        !           188: **
        !           189: **             Choose_buf guarantees that the buffer will be reset
        !           190: **             if it was used previously for a different relation.
        !           191: **
        !           192: **     Choose_buf -- choose a buffer for use with the given relation on
        !           193: **     the given page. The current algorithm is to allow only one buffer
        !           194: **     per relation. If a relation does not have a buffer, it is given a
        !           195: **     free one (if any) or else the Least Recently Used.
        !           196: **
        !           197: **     Trace Flags:
        !           198: **             29.0,1
        !           199: */
        !           200: 
        !           201: struct accbuf *
        !           202: choose_buf(dx, pageid)
        !           203: DESC   *dx;
        !           204: long   pageid;
        !           205: {
        !           206:        register struct accbuf  *b, *free;
        !           207:        register DESC           *d;
        !           208:        struct accbuf           *mine;
        !           209: 
        !           210:        d = dx;
        !           211:        free = mine = NULL;
        !           212: 
        !           213:        for (b = Acc_head; b != 0; b = b->modf)
        !           214:        {
        !           215:                if (b->rel_tupid == -1)
        !           216:                        free = b;
        !           217:                else
        !           218:                        if (d->reltid.ltid == b->rel_tupid)
        !           219:                        {
        !           220:                                if (pageid == b->thispage)
        !           221:                                {
        !           222:                                        if (d->relopn < 0)
        !           223:                                                b->filedesc = d->relfp;
        !           224:                                        return (b);
        !           225:                                }
        !           226:                                mine = b;
        !           227:                        }
        !           228:        }
        !           229: 
        !           230:        /*
        !           231:        ** "Free" and "Mine" now reflect the current state of the buffers.
        !           232:        ** There is no buffer with the currently requested page
        !           233:        */
        !           234: 
        !           235: #      ifdef xATR3
        !           236:        if (tTf(29, 1))
        !           237:                printf("choosebuf free %x,mine %x\n", free, mine);
        !           238: #      endif
        !           239: 
        !           240:        /* no current buffer. Choose a free one or LRU */
        !           241:        if (free == NULL)
        !           242:                free = resetacc(Acc_tail) ? NULL : Acc_tail;    /* error if can't reset the LRU */
        !           243:        if (free)
        !           244:        {
        !           245:                /* copy relevant material (in this order in case of rubout) */
        !           246:                free->filedesc = d->relfp;
        !           247:                free->rel_tupid = d->reltid.ltid;
        !           248:        }
        !           249: 
        !           250: #      ifdef xATR1
        !           251:        if (tTf(29, 0))
        !           252:                printf("choosebuf:rets %x\n", free);
        !           253: #      endif
        !           254:        return (free);
        !           255: }
        !           256: /*
        !           257: **     ACC_CLOSE -- flush any buffers left around
        !           258: **             and then close the files for relation & attribute.
        !           259: **             The relation and attribute relation are normally left open
        !           260: **             until the end of an INGRES session but must be closed
        !           261: **             and re-opened in the dbu's whenever a new overlay is loaded.
        !           262: */
        !           263: 
        !           264: acc_close()
        !           265: {
        !           266:        register int    i;
        !           267: 
        !           268:        if (i = pageflush((struct accbuf *) NULL))
        !           269:                syserr("acc_close: pageflush %d", i);
        !           270:        close(Admin.adreld.relfp);
        !           271:        close(Admin.adattd.relfp);
        !           272:        Admin.adreld.relopn = Admin.adattd.relopn = 0;
        !           273:        if (Alockdes >= 0)
        !           274:                close(Alockdes);
        !           275:        Alockdes = -1;
        !           276:        Acc_init = FALSE;
        !           277:        return (0);
        !           278: }

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