![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / sam|
Return to disc.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / sam |
1.1 ! root 1: #include "sam.h" ! 2: ! 3: /* ! 4: * Guarantee: No compaction from Dread, Dinsert, Ddelete, Dreplace ! 5: */ ! 6: static Discdesc desc[NBUFFILES]; ! 7: static bkalloc(); ! 8: static bkfree(); ! 9: static int bkread(); ! 10: static int bkwrite(); ! 11: static char tempnam[20]; ! 12: ! 13: Discdesc * ! 14: Dstart() ! 15: { ! 16: register i; ! 17: register Discdesc *dd; ! 18: register fd; ! 19: for(i=0, dd=desc; dd->fd; i++, dd++) ! 20: if(i==NBUFFILES-1) ! 21: panic("too many buffer files"); ! 22: if(tempnam[0]==0) ! 23: sprint(tempnam, "/tmp/sam%d", getpid()); ! 24: fd=creat(tempnam, 0600); ! 25: if(fd<0){ ! 26: unlink(tempnam); ! 27: fd=creat(tempnam, 0600); ! 28: } ! 29: if(fd<0 || (close(fd), fd=open(tempnam, 2))<0) ! 30: panic("can't create buffer file"); ! 31: closeonexec(fd); ! 32: unlink(tempnam); ! 33: dd->fd=fd; ! 34: return dd; ! 35: } ! 36: Dclosefd() ! 37: { ! 38: register i; ! 39: for(i=0; i<NBUFFILES; i++) ! 40: if(desc[i].fd) ! 41: close(desc[i].fd); ! 42: } ! 43: Disc * ! 44: Dopen(dd) ! 45: Discdesc *dd; ! 46: { ! 47: register Disc *d; ! 48: d=new(Disc, 1); ! 49: d->desc=dd; ! 50: return d; ! 51: } ! 52: Dclose(d) ! 53: register Disc *d; ! 54: { ! 55: register i; ! 56: for(i=d->block.nused; --i>=0; ) /* backwards because bkfree() stacks */ ! 57: bkfree(d, i); ! 58: gcfree((uchar *)d->block.ptr); ! 59: free((uchar *)d); ! 60: } ! 61: int ! 62: Dread(d, addr, n, p1) ! 63: register Disc *d; ! 64: uchar *addr; ! 65: int n; ! 66: Posn p1; ! 67: { ! 68: register i, nb, nr; ! 69: register Posn p=0, p2=p1+n; ! 70: for(i=0; i<d->block.nused; i++){ ! 71: if((p+=d->block.ptr[i].nbytes)>p1){ ! 72: p-=d->block.ptr[i].nbytes; ! 73: goto out; ! 74: } ! 75: } ! 76: if(p==p1) ! 77: return 0; /* eof */ ! 78: return -1; /* past eof */ ! 79: out: ! 80: n=0; ! 81: if(p!=p1){ /* trailing partial block */ ! 82: nb=d->block.ptr[i].nbytes; ! 83: if(p2>p+nb) ! 84: nr=nb-(p1-p); ! 85: else ! 86: nr=p2-p1; ! 87: bkread(d, addr, nr, i, (int)(p1-p)); ! 88: /* advance to next block */ ! 89: p+=nb; ! 90: addr+=nr; ! 91: n+=nr; ! 92: i++; ! 93: } ! 94: /* whole blocks */ ! 95: while(p<p2 && (nb=d->block.ptr[i].nbytes)<=p2-p){ ! 96: if(i>=d->block.nused) ! 97: return n; /* eof */ ! 98: bkread(d, addr, nb, i, 0); ! 99: p+=nb; ! 100: addr+=nb; ! 101: n+=nb; ! 102: i++; ! 103: } ! 104: if(p<p2){ /* any initial partial block left? */ ! 105: nr=p2-p; ! 106: nb=d->block.ptr[i].nbytes; ! 107: if(nr>nb) ! 108: nr=nb; /* eof */ ! 109: /* just read in the part that survives */ ! 110: bkread(d, addr, nr, i, 0); ! 111: n+=nr; ! 112: } ! 113: return n; ! 114: } ! 115: Dinsert(d, addr, n, p0) ! 116: register Disc *d; ! 117: uchar *addr; /* if null, just make space */ ! 118: int n; ! 119: Posn p0; ! 120: { ! 121: register i, nb, ni; ! 122: register Posn p=0; ! 123: uchar hold[BLOCKSIZE]; ! 124: int nhold; ! 125: for(i=0; i<d->block.nused; i++){ ! 126: if((p+=d->block.ptr[i].nbytes)>=p0){ ! 127: p-=d->block.ptr[i].nbytes; ! 128: goto out; ! 129: } ! 130: } ! 131: if(p!=p0) ! 132: panic("Dinsert"); /* beyond eof */ ! 133: out: ! 134: d->nbytes+=n; ! 135: nhold=0; ! 136: if(i<d->block.nused && (nb=d->block.ptr[i].nbytes)>p0-p){ ! 137: nhold=nb-(p0-p); ! 138: bkread(d, hold, nhold, i, (int)(p0-p)); ! 139: d->block.ptr[i].nbytes-=nhold; /* no write necessary */ ! 140: } ! 141: /* insertion point is now at end of block i (which may not exist) */ ! 142: while(n>0){ ! 143: if(i<d->block.nused && (nb=d->block.ptr[i].nbytes)<BLOCKSIZE/2){ ! 144: /* fill this block */ ! 145: if(nb+n>BLOCKSIZE) ! 146: ni=BLOCKSIZE/2-nb; ! 147: else ! 148: ni=n; ! 149: if(addr) ! 150: bkwrite(d, addr, ni, i, nb); ! 151: nb+=ni; ! 152: }else{ /* make new block */ ! 153: if(i<d->block.nused) ! 154: i++; /* put after this block, if it exists */ ! 155: bkalloc(d, i); ! 156: if(n>BLOCKSIZE) ! 157: ni=BLOCKSIZE/2; ! 158: else ! 159: ni=n; ! 160: if(addr) ! 161: bkwrite(d, addr, ni, i, 0); ! 162: nb=ni; ! 163: } ! 164: d->block.ptr[i].nbytes=nb; ! 165: if(addr) ! 166: addr+=ni; ! 167: n-=ni; ! 168: } ! 169: if(nhold){ ! 170: if(i<d->block.nused && (nb=d->block.ptr[i].nbytes)+nhold<BLOCKSIZE){ ! 171: /* fill this block */ ! 172: bkwrite(d, hold, nhold, i, nb); ! 173: nb+=nhold; ! 174: }else{ /* make new block */ ! 175: if(i<d->block.nused) ! 176: i++; /* put after this block, if it exists */ ! 177: bkalloc(d, i); ! 178: bkwrite(d, hold, nhold, i, 0); ! 179: nb=nhold; ! 180: } ! 181: d->block.ptr[i].nbytes=nb; ! 182: } ! 183: } ! 184: Ddelete(d, p1, p2) ! 185: register Disc *d; ! 186: Posn p1, p2; ! 187: { ! 188: register i, nb, nd; ! 189: register Posn p=0; ! 190: uchar buf[BLOCKSIZE]; ! 191: for(i=0; i<d->block.nused; i++){ ! 192: if((p+=d->block.ptr[i].nbytes)>p1){ ! 193: p-=d->block.ptr[i].nbytes; ! 194: goto out; ! 195: } ! 196: } ! 197: if(p1!=d->nbytes || p2!=p1) ! 198: panic("Ddelete"); ! 199: return; /* beyond eof */ ! 200: out: ! 201: d->nbytes-=p2-p1; ! 202: if(p!=p1){ /* throw away partial block */ ! 203: nb=d->block.ptr[i].nbytes; ! 204: bkread(d, buf, nb, i, 0); ! 205: if(p2>=p+nb) ! 206: nd=nb-(p1-p); ! 207: else{ ! 208: nd=p2-p1; ! 209: bcopy(buf+(p1-p)+nd, buf+nb, buf+(p1-p), 1); ! 210: } ! 211: nb-=nd; ! 212: bkwrite(d, buf, nb, i, 0); ! 213: d->block.ptr[i].nbytes=nb; ! 214: p2-=nd; ! 215: /* advance to next block */ ! 216: p+=nb; ! 217: i++; ! 218: } ! 219: /* throw away whole blocks */ ! 220: while(p<p2 && (nb=d->block.ptr[i].nbytes)<=p2-p){ ! 221: if(i>=d->block.nused) ! 222: panic("Ddelete 2"); ! 223: bkfree(d, i); ! 224: p2-=nb; ! 225: } ! 226: if(p>=p2) /* any initial partial block left to delete? */ ! 227: return; /* no */ ! 228: nd=p2-p; ! 229: nb=d->block.ptr[i].nbytes; ! 230: /* just read in the part that survives */ ! 231: bkread(d, buf, nb-=nd, i, nd); ! 232: /* a little block merging */ ! 233: if(nb<BLOCKSIZE/2 && i>0 && (nd=d->block.ptr[i-1].nbytes)<BLOCKSIZE/2){ ! 234: bcopy(buf, buf+nb, buf+nd, -1); ! 235: bkread(d, buf, nd, --i, 0); ! 236: bkfree(d, i); ! 237: nb+=nd; ! 238: } ! 239: bkwrite(d, buf, nb, i, 0); ! 240: d->block.ptr[i].nbytes=nb; ! 241: } ! 242: Dreplace(d, p1, p2, addr, n) ! 243: register Disc *d; ! 244: Posn p1, p2; ! 245: uchar *addr; ! 246: int n; ! 247: { ! 248: register i, nb, nr; ! 249: register Posn p=0; ! 250: uchar buf[BLOCKSIZE]; ! 251: if(p2-p1>n) ! 252: Ddelete(d, p1+n, p2); ! 253: else if(p2-p1<n) ! 254: Dinsert(d, (uchar *)0, (int)(n-(p2-p1)), p2); ! 255: p2=p1+n; ! 256: /* they're now conformal; replace in place */ ! 257: for(i=0; i<d->block.nused; i++){ ! 258: if((p+=d->block.ptr[i].nbytes)>p1){ ! 259: p-=d->block.ptr[i].nbytes; ! 260: goto out; ! 261: } ! 262: } ! 263: panic("Dreplace"); ! 264: out: ! 265: if(p!=p1){ /* trailing partial block */ ! 266: nb=d->block.ptr[i].nbytes; ! 267: bkread(d, buf, nb, i, 0); ! 268: if(p2>p+nb) ! 269: nr=nb-(p1-p); ! 270: else ! 271: nr=p2-p1; ! 272: bcopy(addr, addr+nr, buf+p1-p, 1); ! 273: bkwrite(d, buf, nb, i, 0); ! 274: /* advance to next block */ ! 275: p+=nb; ! 276: addr+=nr; ! 277: i++; ! 278: } ! 279: /* whole blocks */ ! 280: while(p<p2 && (nb=d->block.ptr[i].nbytes)<=p2-p){ ! 281: if(i>=d->block.nused) ! 282: panic("Dreplace 2"); ! 283: bkwrite(d, addr, nb, i, 0); ! 284: p+=nb; ! 285: addr+=nb; ! 286: i++; ! 287: } ! 288: if(p<p2){ /* any initial partial block left? */ ! 289: nr=p2-p; ! 290: nb=d->block.ptr[i].nbytes; ! 291: /* just read in the part that survives */ ! 292: bkread(d, buf+nr, nb-nr, i, nr); ! 293: bcopy(addr, addr+nr, buf, 1); ! 294: bkwrite(d, buf, nb, i, 0); ! 295: } ! 296: } ! 297: static int ! 298: bkread(d, loc, n, bk, off) ! 299: Disc *d; ! 300: uchar *loc; ! 301: int n; ! 302: int bk; ! 303: int off; ! 304: { ! 305: Lseek(d->desc->fd, BLOCKSIZE*(long)d->block.ptr[bk].bnum+off, 0); ! 306: return Read(d->desc->fd, loc, n); ! 307: } ! 308: static int ! 309: bkwrite(d, loc, n, bk, off) ! 310: Disc *d; ! 311: uchar *loc; ! 312: int n; ! 313: int bk; ! 314: int off; ! 315: { ! 316: Lseek(d->desc->fd, BLOCKSIZE*(long)d->block.ptr[bk].bnum+off, 0); ! 317: return Write(d->desc->fd, loc, n); ! 318: } ! 319: static ! 320: bkalloc(d, n) ! 321: register Disc *d; ! 322: int n; ! 323: { ! 324: register Discdesc *dd=d->desc; ! 325: register bnum; ! 326: if(dd->free.nused) ! 327: bnum=dd->free.ptr[--dd->free.nused]; ! 328: else ! 329: bnum=dd->nbk++; ! 330: nocompact(); ! 331: inslist((List *)&d->block, n, 0L); ! 332: compactok(); ! 333: d->block.ptr[n].bnum=bnum; ! 334: } ! 335: static ! 336: bkfree(d, n) ! 337: Disc *d; ! 338: int n; ! 339: { ! 340: Discdesc *dd=d->desc; ! 341: nocompact(); ! 342: inslist(&dd->free, dd->free.nused, (long)d->block.ptr[n].bnum); ! 343: compactok(); ! 344: dellist((List *)&d->block, n); ! 345: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.