Return to page.c CVS log

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

Annotation of 43BSD/ingres/source/iutil/page.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      <sccs.h>
        !             6: 
        !             7: SCCSID(@(#)page.c      8.3     2/8/85)
        !             8: 
        !             9: /*
        !            10: **     UNIX read/write counters
        !            11: */
        !            12: 
        !            13: long   Accuread, Accuwrite;
        !            14: long   Accusread;
        !            15: 
        !            16: /*
        !            17: **     GETPAGE - get the page on which tid is found
        !            18: **
        !            19: **
        !            20: **     Parameters:
        !            21: **             d - descriptor for relation
        !            22: **             tid - tid which specifies the page
        !            23: **
        !            24: **     Return Codes:
        !            25: **             0 - success             
        !            26: **             -1, -2 - AMREAD_ERR, AMWRITE_ERR                
        !            27: **
        !            28: **     Trace Flags:
        !            29: **             26.9, 26.10
        !            30: **
        !            31: **     Called by:
        !            32: **             fill_rel(), add_ovflo(), bndxsearch(), delete(),
        !            33: **             get(), getequal(), ndxsearch(), noclose(), replace()
        !            34: **             scan_dups()
        !            35: **
        !            36: */
        !            37: get_page(d, tid)
        !            38: register DESC  *d;
        !            39: TID            *tid;
        !            40: {
        !            41:        register int            i;
        !            42:        long                    pageid;
        !            43:        register struct accbuf  *b;
        !            44:        struct accbuf           *b1;
        !            45:        int                     lk;             /* lock condition*/
        !            46:        extern struct accbuf    *choose_buf();
        !            47:        extern long             lseek();
        !            48: 
        !            49: #      ifdef xATR3
        !            50:        if (tTf(26, 9))
        !            51:        {
        !            52:                printf("GET_PAGE: %.14s,", d->reldum.relid);
        !            53:                dumptid(tid);
        !            54:        }
        !            55: #      endif
        !            56: 
        !            57:        pluck_page(tid, &pageid);
        !            58:        if ((b = choose_buf(d, pageid)) == NULL)
        !            59:                return (-1);
        !            60:        top_acc(b);
        !            61:        lk = Acclock && (d->reldum.relstat & S_CONCUR) && (d->relopn < 0);
        !            62:        if ((b->thispage != pageid) || (lk && !(b->bufstatus & BUF_LOCKED)))
        !            63:        {
        !            64:                if (i = pageflush(b))
        !            65:                        return (i);
        !            66: #              ifdef xATR1
        !            67:                if (tTf(26, 10))
        !            68:                {
        !            69:                        printf("GET_PAGE: rdg pg %ld", pageid);
        !            70:                        printf(",relid ");
        !            71:                        dumptid((TID *) &d->reltid);
        !            72:                }
        !            73: #              endif
        !            74:                b->thispage = pageid;
        !            75:                if (lk)
        !            76:                {
        !            77:                        b1 = Acc_head;
        !            78:                        for (; b1 != 0; b1 = b1->modf)
        !            79:                                if (b1->bufstatus & BUF_LOCKED)
        !            80:                                        pageflush(b1);  /*  */
        !            81:                        if (setpgl(b) < 0)
        !            82:                                syserr("get-page: lk err");
        !            83:                }
        !            84:                if ((lseek(d->relfp, (long)(pageid * PGSIZE), 0) == -1) ||
        !            85:                    (read(d->relfp, (char *) b, PGSIZE) != PGSIZE))
        !            86:                {
        !            87:                        resetacc(b);
        !            88:                        return (acc_err(AMREAD_ERR));
        !            89:                }
        !            90:                Accuread++;
        !            91:                if (d->reldum.relstat & S_CATALOG)
        !            92:                {
        !            93:                        Accusread++;
        !            94:                }
        !            95:        }
        !            96:        return (0);
        !            97: }
        !            98: 
        !            99: /*
        !           100: **     PAGEFLUSH - flush the buffered page to disk
        !           101: **
        !           102: **     Parameters:
        !           103: **             buf - the buffer
        !           104: **
        !           105: **     Return Codes:
        !           106: **             0 -- successful
        !           107: **             AMWRITE_ERR - error in writing
        !           108: **
        !           109: **     Trace Flags:
        !           110: **             29.2, 29.3
        !           111: **
        !           112: */
        !           113: pageflush(buf)
        !           114: struct accbuf  *buf;
        !           115: {
        !           116:        register struct accbuf  *b;
        !           117:        register int            allbufs;
        !           118:        int                     err;
        !           119: 
        !           120:        b = buf;
        !           121: #      ifdef xATR3
        !           122:        if (tTf(29, 2))
        !           123:        {
        !           124:                printf("PAGEFLUSH: %x=", b);
        !           125:                if (b != NULL)
        !           126:                        dumptid(&b->rel_tupid);
        !           127:                else
        !           128:                        printf("all\n");
        !           129:        }
        !           130: #      endif
        !           131:        err = FALSE;
        !           132:        allbufs = FALSE;
        !           133:        if (b == 0)
        !           134:        {
        !           135:                b = Acc_buf;
        !           136:                allbufs = TRUE;
        !           137:        }
        !           138: 
        !           139:        do
        !           140:        {
        !           141:                if (b->bufstatus & BUF_DIRTY)
        !           142:                {
        !           143: #                      ifdef xATR1
        !           144:                        if (tTf(29, 3))
        !           145:                        {
        !           146:                                printf("PAGEFLUSH: wr pg %ld", b->thispage);
        !           147:                                printf(",stat %d,relid ", b->bufstatus);
        !           148:                                dumptid((TID *) &b->rel_tupid);
        !           149:                        }
        !           150: #                      endif
        !           151: 
        !           152: 
        !           153:                        b->bufstatus &= ~BUF_DIRTY;
        !           154:                        if ((lseek(b->filedesc, (long)(b->thispage * PGSIZE), 0)== -1) ||
        !           155:                            (write(b->filedesc, (char *) b, PGSIZE) != PGSIZE))
        !           156:                        {
        !           157:                                resetacc(b);
        !           158:                                err = TRUE;
        !           159:                        }
        !           160:                        Accuwrite++;
        !           161: 
        !           162:                }
        !           163:                if (Acclock && b->bufstatus & BUF_LOCKED)
        !           164:                        unlpg(b);
        !           165: 
        !           166:        } while (allbufs && (b = b->modf) != NULL);
        !           167: 
        !           168:        if (err)
        !           169:                return (acc_err(AMWRITE_ERR));
        !           170: 
        !           171:        return (0);
        !           172: }
        !           173: /*
        !           174: **  ACC_ERR -- set global error indicator "Accerror"
        !           175: **
        !           176: **     Trace Flags:
        !           177: **             20.4-5
        !           178: */
        !           179: 
        !           180: acc_err(errnum)
        !           181: int    errnum;
        !           182: {
        !           183:        Accerror = errnum;
        !           184: #      ifdef xATR1
        !           185:        tTfp(20, 4, "ACC_ERR: %d\n", Accerror);
        !           186: #      endif
        !           187:        return (Accerror);
        !           188: }

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