Return to add_ovflo.c CVS log

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

Annotation of 42BSD/ingres/source/iutil/add_ovflo.c, revision 1.1.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(@(#)add_ovflo.c 7.1     2/5/81)
                      8: 
                      9: /*
                     10: **     ADD_OVFLO -- Allocates an overflow page which will be
                     11: **             attached to current page.  TID must be for current page.
                     12: **             TID will be updated to id of new overflow page.
                     13: */
                     14: 
                     15: add_ovflo(dx, tid)
                     16: DESC   *dx;
                     17: TID    *tid;
                     18: {
                     19:        register DESC           *d;
                     20:        register struct accbuf  *b;
                     21:        extern struct accbuf    *choose_buf();
                     22:        register int            lk;
                     23:        int                     i;
                     24:        long                    mpage, newpage;
                     25:        TID                     tidx;
                     26: 
                     27:        d = dx;
                     28: #      ifdef xATR2
                     29:        if (tTf(26, 3))
                     30:                printf("ADD_OVFLO:\n");
                     31: #      endif
                     32: 
                     33:        /*
                     34:        **      save main page pointer so that it may be used when
                     35:        **      setting up new overflow page.
                     36:        */
                     37:        mpage = Acc_head->mainpg;
                     38: 
                     39:        if (lk = (Acclock && (d->reldum.relstat & S_CONCUR) && (d->relopn < 0 )))
                     40:        {
                     41:                setcsl(Acc_head->rel_tupid);
                     42:                Acclock = FALSE;
                     43:        }
                     44: 
                     45:        /*
                     46:        **      Determine last page of the relation
                     47:        */
                     48:        last_page(d, &tidx, Acc_head);
                     49:        pluck_page(&tidx, &newpage);
                     50:        newpage++;
                     51: 
                     52:        /*
                     53:        **      choose an available buffer as victim for setting up
                     54:        **      overflow page.
                     55:        */
                     56:        if ((b = choose_buf(d, newpage)) == NULL)
                     57:        {
                     58:                if (lk)
                     59:                {
                     60:                        Acclock = TRUE;
                     61:                        unlcs(Acc_head->rel_tupid);
                     62:                }
                     63:                return(-1);
                     64:        }
                     65: 
                     66:        /*
                     67:        **      setup overflow page
                     68:        */
                     69: 
                     70:        b->mainpg = mpage;
                     71:        b->ovflopg = 0;
                     72:        b->thispage = newpage;
                     73:        b->linetab[0] = (int) b->firstup - (int) b;
                     74:        b->nxtlino = 0;
                     75:        b->bufstatus |= BUF_DIRTY;
                     76:        if (pageflush(b))
                     77:                return (-2);
                     78: 
                     79:        /*
                     80:        **      now that overflow page has successfully been written,
                     81:        **      get the old current page back and link the new overflow page
                     82:        **      to it.
                     83:        **      If the relation is a heap then don't leave the old main
                     84:        **      page around in the buffers. This is done on the belief
                     85:        **      that it will never be accessed again.
                     86:        */
                     87: 
                     88:        if (get_page(d, tid))
                     89:                return (-3);
                     90:        Acc_head->ovflopg = newpage;
                     91:        Acc_head->bufstatus |= BUF_DIRTY;
                     92:        i = pageflush(Acc_head);
                     93:        if (lk)
                     94:        {
                     95:                Acclock = TRUE;
                     96:                unlcs(Acc_head->rel_tupid);
                     97:        }
                     98:        if (i)
                     99:                return (-4);
                    100:        if (abs(d->reldum.relspec) == M_HEAP)
                    101:                resetacc(Acc_head);     /* no error is possible */
                    102: 
                    103:        /*
                    104:        **      now bring the overflow page back and make it current.
                    105:        **      if the overflow page is still in AM cache, then this will not
                    106:        **      cause any disk activity.
                    107:        */
                    108: 
                    109:        stuff_page(tid, &newpage);
                    110:        if (get_page(d, tid))
                    111:                return (-5);
                    112:        return (0);
                    113: }

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