--- ray/src/hd/holofile.c 1999/03/09 08:40:11 3.39 +++ ray/src/hd/holofile.c 2008/12/04 23:34:00 3.58 @@ -1,22 +1,26 @@ -/* Copyright (c) 1999 Silicon Graphics, Inc. */ - #ifndef lint -static char SCCSid[] = "$SunId$ SGI"; +static const char RCSid[] = "$Id: holofile.c,v 3.58 2008/12/04 23:34:00 greg Exp $"; #endif - /* * Routines for managing holodeck files * * 9/30/97 GWLarson */ +#include "copyright.h" + +#include + +#include "platform.h" +#include "rtprocess.h" + #include "holo.h" #ifndef CACHESIZE -#ifdef BIGMEM -#define CACHESIZE 17 /* default cache size (Mbytes, 0==inf) */ +#ifdef SMLMEM +#define CACHESIZE 10 #else -#define CACHESIZE 5 +#define CACHESIZE 100 /* default cache size (Mbytes, 0==inf) */ #endif #endif #ifndef FREEBEAMS @@ -26,7 +30,7 @@ static char SCCSid[] = "$SunId$ SGI"; #define PCTFREE 15 /* maximum fraction to free (%) */ #endif #ifndef MAXFRAGB -#define MAXFRAGB 16 /* fragment blocks/file to track (0==inf) */ +#define MAXFRAGB 64 /* fragment blocks/file to track (0==inf) */ #endif #ifndef FF_DEFAULT /* when to free a beam fragment */ @@ -52,25 +56,74 @@ HOLO *hdlist[HDMAX+1]; /* holodeck pointers (NULL term static struct fraglist { short nlinks; /* number of holodeck sections using us */ - short writerr; /* write error encountered */ + short writable; /* 0 read-only, <0 write error encountered */ int nfrags; /* number of known fragments */ BEAMI *fi; /* fragments, descending file position */ - long flen; /* last known file length */ + off_t flen; /* last known file length */ } *hdfragl; /* fragment lists, indexed by file descriptor */ static int nhdfragls; /* size of hdfragl array */ +static HOLO *hdalloc(HDGRID *hproto); +static char *hdrealloc(char *ptr, unsigned siz, char *rout); +static void hdattach(int fd, int wr); +static void hdrelease(int fd); +static void hdmarkdirty(HOLO *hp, int i); +static unsigned int hdmemuse(int all); +static int hdfilord(const void *hb1, const void *hb2); +static off_t hdallocfrag(int fd, uint32 nrays); +static int hdsyncbeam(HOLO *hp, int i); +static int hdlrulist(HDBEAMI *hb, int nents, int n, HOLO *hp); +static int hdfreecache(int pct, HOLO *honly); + + +HOLO * +hdalloc( /* allocate and set holodeck section based on grid */ + HDGRID *hproto +) +{ + HOLO hdhead; + register HOLO *hp; + int n; + /* copy grid to temporary header */ + memcpy((void *)&hdhead, (void *)hproto, sizeof(HDGRID)); + /* compute grid vectors and sizes */ + hdcompgrid(&hdhead); + /* allocate header with directory */ + n = sizeof(HOLO)+nbeams(&hdhead)*sizeof(BEAMI); + if ((hp = (HOLO *)malloc(n)) == NULL) + return(NULL); + /* copy header information */ + *hp = hdhead; + /* allocate and clear beam list */ + hp->bl = (BEAM **)malloc((nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM)); + if (hp->bl == NULL) { + free((void *)hp); + return(NULL); + } + memset((void *)hp->bl, '\0', (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM)); + hp->bl[0] = (BEAM *)(hp->bl+nbeams(hp)+1); /* set blglob(hp) */ + hp->fd = -1; + hp->dirty = 0; + hp->priv = NULL; + /* clear beam directory */ + memset((void *)hp->bi, '\0', (nbeams(hp)+1)*sizeof(BEAMI)); + return(hp); /* all is well */ +} + + char * -hdrealloc(ptr, siz, rout) /* (re)allocate memory, retry then error */ -char *ptr; -unsigned siz; -char *rout; +hdrealloc( /* (re)allocate memory, retry then error */ + char *ptr, + unsigned siz, + char *rout +) { register char *newp; /* call malloc/realloc */ if (ptr == NULL) newp = (char *)malloc(siz); - else newp = (char *)realloc(ptr, siz); + else newp = (char *)realloc((void *)ptr, siz); /* check success */ if (newp == NULL && rout != NULL) { hdfreecache(25, NULL); /* free some memory */ @@ -85,49 +138,58 @@ char *rout; } -hdattach(fd) /* start tracking file fragments for some section */ -register int fd; +void +hdattach( /* start tracking file fragments for some section */ + register int fd, + int wr +) { if (fd >= nhdfragls) { hdfragl = (struct fraglist *)hdrealloc((char *)hdfragl, (fd+1)*sizeof(struct fraglist), "hdattach"); - bzero((char *)(hdfragl+nhdfragls), - (fd+1-nhdfragls)*sizeof(struct fraglist)); + memset((void *)(hdfragl+nhdfragls), + '\0', (fd+1-nhdfragls)*sizeof(struct fraglist)); nhdfragls = fd+1; } hdfragl[fd].nlinks++; - hdfragl[fd].flen = lseek(fd, 0L, 2); /* get file length */ + hdfragl[fd].writable = wr; /* set writable flag */ + /* get file length */ + hdfragl[fd].flen = lseek(fd, (off_t)0, SEEK_END); } /* Do we need a routine to locate file fragments given known occupants? */ -hdrelease(fd) /* stop tracking file fragments for some section */ -register int fd; +void +hdrelease( /* stop tracking file fragments for some section */ + register int fd +) { - if (fd < 0 | fd >= nhdfragls || !hdfragl[fd].nlinks) + if ((fd < 0) | (fd >= nhdfragls) || !hdfragl[fd].nlinks) return; if (!--hdfragl[fd].nlinks && hdfragl[fd].nfrags) { - free((char *)hdfragl[fd].fi); + free((void *)hdfragl[fd].fi); hdfragl[fd].fi = NULL; hdfragl[fd].nfrags = 0; } } -HOLO * -hdinit(fd, hproto) /* initialize a holodeck section in a file */ -int fd; /* corresponding file descriptor */ -HDGRID *hproto; /* holodeck section grid */ +extern HOLO * +hdinit( /* initialize a holodeck section in a file */ + int fd, /* corresponding file descriptor */ + HDGRID *hproto /* holodeck section grid */ +) { - long rtrunc; - long fpos; + off_t rtrunc; + off_t fpos; + int writable; register HOLO *hp; register int n; /* prepare for system errors */ errno = 0; - if ((fpos = lseek(fd, 0L, 1)) < 0) + if ((fpos = lseek(fd, (off_t)0, SEEK_CUR)) < 0) error(SYSTEM, "cannot determine holodeck file position"); if (hproto == NULL) { /* assume we're loading it */ HDGRID hpr; @@ -148,7 +210,14 @@ HDGRID *hproto; /* holodeck section grid */ error(WARNING, "dirty holodeck section"); break; } - } else { /* assume we're creating it */ + /* check writability */ + if (fd < nhdfragls && hdfragl[fd].nlinks) + writable = hdfragl[fd].writable; + else + writable = lseek(fd, fpos, SEEK_SET) == fpos && + write(fd, (char *)hp, sizeof(HDGRID)) == + sizeof(HDGRID); + } else { /* else assume we're creating it */ if ((hp = hdalloc(hproto)) == NULL) goto memerr; /* write header and skeleton */ @@ -157,22 +226,24 @@ HDGRID *hproto; /* holodeck section grid */ sizeof(HDGRID) || write(fd, (char *)(hp->bi+1), n) != n) error(SYSTEM, "cannot write header to holodeck file"); + writable = 1; } hp->fd = fd; hp->dirty = 0; biglob(hp)->fo = fpos + sizeof(HDGRID); /* start tracking fragments */ - hdattach(fd); + hdattach(fd, writable); /* check rays on disk */ fpos = hdfilen(fd); biglob(hp)->nrd = rtrunc = 0; for (n = hproto == NULL ? nbeams(hp) : 0; n > 0; n--) - if (hp->bi[n].nrd) + if (hp->bi[n].nrd) { if (hp->bi[n].fo+hp->bi[n].nrd*sizeof(RAYVAL) > fpos) { rtrunc += hp->bi[n].nrd; hp->bi[n].nrd = 0; } else biglob(hp)->nrd += hp->bi[n].nrd; + } if (rtrunc) { sprintf(errmsg, "truncated section, %ld rays lost (%.1f%%)", rtrunc, 100.*rtrunc/(rtrunc+biglob(hp)->nrd)); @@ -188,20 +259,24 @@ HDGRID *hproto; /* holodeck section grid */ return(hp); memerr: error(SYSTEM, "cannot allocate holodeck grid"); + return NULL; /* pro forma return */ } -hdmarkdirty(hp, i) /* mark holodeck directory position dirty */ -register HOLO *hp; -int i; +void +hdmarkdirty( /* mark holodeck directory position dirty */ + register HOLO *hp, + int i +) { static BEAMI smudge = {0, -1}; int mindist, minpos; register int j; if (!hp->dirty++) { /* write smudge first time */ - if (lseek(hp->fd, biglob(hp)->fo+(i-1)*sizeof(BEAMI), 0) < 0 - || write(hp->fd, (char *)&smudge, + if (lseek(hp->fd, biglob(hp)->fo+(i-1)*sizeof(BEAMI), + SEEK_SET) < 0 || + write(hp->fd, (char *)&smudge, sizeof(BEAMI)) != sizeof(BEAMI)) error(SYSTEM, "seek/write error in hdmarkdirty"); hp->dirseg[0].s = i; @@ -215,7 +290,7 @@ int i; hp->dirseg[j].n = 1; break; } - copystruct(hp->dirseg+j, hp->dirseg+(j-1)); + *(hp->dirseg+j) = *(hp->dirseg+(j-1)); } do { /* check neighbors */ mindist = nbeams(hp); /* find closest */ @@ -237,15 +312,16 @@ int i; hp->dirseg[minpos].n - hp->dirseg[j].s; hp->dirty--; while (++j < hp->dirty) /* close the gap */ - copystruct(hp->dirseg+j, hp->dirseg+(j+1)); + *(hp->dirseg+j) = *(hp->dirseg+(j+1)); } while (mindist <= MINDIRSEL); } -int -hdsync(hp, all) /* update beams and directory on disk */ -register HOLO *hp; -int all; +extern int +hdsync( /* update beams and directory on disk */ + register HOLO *hp, + int all +) { register int j, n; @@ -264,7 +340,7 @@ int all; errno = 0; /* write dirty segments */ for (j = 0; j < hp->dirty; j++) { if (lseek(hp->fd, biglob(hp)->fo + - (hp->dirseg[j].s-1)*sizeof(BEAMI), 0) < 0) + (hp->dirseg[j].s-1)*sizeof(BEAMI), SEEK_SET) < 0) error(SYSTEM, "cannot seek on holodeck file"); n = hp->dirseg[j].n * sizeof(BEAMI); if (write(hp->fd, (char *)(hp->bi+hp->dirseg[j].s), n) != n) @@ -275,9 +351,10 @@ int all; } -unsigned -hdmemuse(all) /* return memory usage (in bytes) */ -int all; /* include overhead (painful) */ +unsigned int +hdmemuse( /* return memory usage (in bytes) */ + int all /* include overhead (painful) */ +) { long total = 0; register int i, j; @@ -304,62 +381,63 @@ int all; /* include overhead (painful) */ } -long -hdfilen(fd) /* return file length for fd */ -int fd; +extern off_t +hdfilen( /* return file length for fd */ + int fd +) { - long fpos, flen; + off_t fpos, flen; if (fd < 0) return(-1); if (fd >= nhdfragls || !hdfragl[fd].nlinks) { - if ((fpos = lseek(fd, 0L, 1)) < 0) + if ((fpos = lseek(fd, (off_t)0, SEEK_CUR)) < 0) return(-1); - flen = lseek(fd, 0L, 2); - lseek(fd, fpos, 0); + flen = lseek(fd, (off_t)0, SEEK_END); + lseek(fd, fpos, SEEK_SET); return(flen); } return(hdfragl[fd].flen); } -long -hdfiluse(fd, all) /* compute file usage (in bytes) */ -int fd; /* open file descriptor to check */ -int all; /* include overhead and unflushed data */ +extern off_t +hdfiluse( /* compute file usage (in bytes) */ + int fd /* open file descriptor to check */ +) { - long total = 0; - register int i, j; + off_t total = 0; + register int j; for (j = 0; hdlist[j] != NULL; j++) { if (hdlist[j]->fd != fd) continue; total += biglob(hdlist[j])->nrd * sizeof(RAYVAL); - if (all) { - for (i = nbeams(hdlist[j]); i > 0; i--) - if (hdlist[j]->bl[i] != NULL) - total += sizeof(RAYVAL) * + total += nbeams(hdlist[j])*sizeof(BEAMI) + sizeof(HDGRID); +#if 0 + for (i = nbeams(hdlist[j]); i > 0; i--) + if (hdlist[j]->bl[i] != NULL) + total += sizeof(RAYVAL) * (hdlist[j]->bl[i]->nrm - hdlist[j]->bi[i].nrd); - total += sizeof(HDGRID) + - nbeams(hdlist[j])*sizeof(BEAMI); - } +#endif } - return(total); /* does not include fragments */ + return(total); /* doesn't include fragments, unflushed rays */ } -RAYVAL * -hdnewrays(hp, i, nr) /* allocate space for add'l rays and return pointer */ -register HOLO *hp; -register int i; -int nr; /* number of new rays desired */ +extern RAYVAL * +hdnewrays( /* allocate space for add'l rays and return pointer */ + register HOLO *hp, + register int i, + int nr /* number of new rays desired */ +) { RAYVAL *p; int n; if (nr <= 0) return(NULL); - CHECK(i < 1 | i > nbeams(hp), + CHECK((i < 1) | (i > nbeams(hp)), CONSISTENCY, "bad beam index given to hdnewrays"); if (hp->bl[i] != NULL) hp->bl[i]->tick = hdclock; /* preempt swap */ @@ -371,7 +449,7 @@ int nr; /* number of new rays desired */ blglob(hp)->nrm += n; if ((n = hp->bl[i]->nrm = hp->bi[i].nrd)) { errno = 0; - if (lseek(hp->fd, hp->bi[i].fo, 0) < 0) + if (lseek(hp->fd, hp->bi[i].fo, SEEK_SET) < 0) error(SYSTEM, "seek error on holodeck file"); n *= sizeof(RAYVAL); if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) @@ -387,20 +465,21 @@ int nr; /* number of new rays desired */ hdfreefrag(hp, i); /* relinquish old fragment */ p = hdbray(hp->bl[i]) + hp->bl[i]->nrm; hp->bl[i]->nrm += nr; /* update in-core structure */ - bzero((char *)p, nr*sizeof(RAYVAL)); + memset((void *)p, '\0', nr*sizeof(RAYVAL)); blglob(hp)->tick = hp->bl[i]->tick = hdclock++; /* update LRU clock */ return(p); /* point to new rays */ } -BEAM * -hdgetbeam(hp, i) /* get beam (from file if necessary) */ -register HOLO *hp; -register int i; +extern BEAM * +hdgetbeam( /* get beam (from file if necessary) */ + register HOLO *hp, + register int i +) { register int n; - CHECK(i < 1 | i > nbeams(hp), + CHECK((i < 1) | (i > nbeams(hp)), CONSISTENCY, "bad beam index given to hdgetbeam"); if (hp->bl[i] == NULL) { /* load from disk */ if (!(n = hp->bi[i].nrd)) @@ -410,7 +489,7 @@ register int i; hp->bl[i] = (BEAM *)hdrealloc(NULL, hdbsiz(n), "hdgetbeam"); blglob(hp)->nrm += hp->bl[i]->nrm = n; errno = 0; - if (lseek(hp->fd, hp->bi[i].fo, 0) < 0) + if (lseek(hp->fd, hp->bi[i].fo, SEEK_SET) < 0) error(SYSTEM, "seek error on holodeck file"); n *= sizeof(RAYVAL); if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) @@ -424,28 +503,33 @@ register int i; int -hdfilord(hb1, hb2) /* order beams for quick loading */ -register HDBEAMI *hb1, *hb2; +hdfilord( /* order beams for quick loading */ + register const void *hb1, + register const void *hb2 +) { - register long c; + register off_t c; /* residents go first */ - if (hb2->h->bl[hb2->b] != NULL) - return(hb1->h->bl[hb1->b] == NULL); - if (hb1->h->bl[hb1->b] != NULL) + if (((HDBEAMI*)hb2)->h->bl[((HDBEAMI*)hb2)->b] != NULL) + return(((HDBEAMI*)hb1)->h->bl[((HDBEAMI*)hb1)->b] == NULL); + if (((HDBEAMI*)hb1)->h->bl[((HDBEAMI*)hb1)->b] != NULL) return(-1); /* otherwise sort by file descriptor */ - if ((c = hb1->h->fd - hb2->h->fd)) - return(c); + if (((HDBEAMI*)hb1)->h->fd != ((HDBEAMI*)hb2)->h->fd) + return(((HDBEAMI*)hb1)->h->fd - ((HDBEAMI*)hb2)->h->fd); /* then by position in file */ - c = hb1->h->bi[hb1->b].fo - hb2->h->bi[hb2->b].fo; + c = ((HDBEAMI*)hb1)->h->bi[((HDBEAMI*)hb1)->b].fo + - ((HDBEAMI*)hb2)->h->bi[((HDBEAMI*)hb2)->b].fo; return(c > 0 ? 1 : c < 0 ? -1 : 0); } -hdloadbeams(hb, n, bf) /* load a list of beams in optimal order */ -register HDBEAMI *hb; /* list gets sorted by hdfilord() */ -int n; /* list length */ -int (*bf)(); /* callback function (optional) */ +extern void +hdloadbeams( /* load a list of beams in optimal order */ + register HDBEAMI *hb, /* list gets sorted by hdfilord() */ + int n, /* list length */ + void (*bf)(BEAM *bp, HDBEAMI *hb) /* callback function (optional) */ +) { unsigned origcachesize, memuse; int bytesloaded, needbytes, bytes2free; @@ -454,10 +538,10 @@ int (*bf)(); /* callback function (optional) */ /* precheck consistency */ if (n <= 0) return; for (i = n; i--; ) - if (hb[i].h==NULL || hb[i].b<1 | hb[i].b>nbeams(hb[i].h)) + if (hb[i].h==NULL || (hb[i].b<1) | (hb[i].b>nbeams(hb[i].h))) error(CONSISTENCY, "bad beam in hdloadbeams"); /* sort list for optimal access */ - qsort((char *)hb, n, sizeof(HDBEAMI), hdfilord); + qsort((void *)hb, n, sizeof(HDBEAMI), hdfilord); bytesloaded = 0; /* run through loaded beams */ for ( ; n && (bp = hb->h->bl[hb->b]) != NULL; n--, hb++) { bp->tick = hdclock; /* preempt swap */ @@ -487,10 +571,11 @@ int (*bf)(); /* callback function (optional) */ } -int -hdfreefrag(hp, i) /* free a file fragment */ -HOLO *hp; -int i; +extern int +hdfreefrag( /* free a file fragment */ + HOLO *hp, + int i +) { register BEAMI *bi = &hp->bi[i]; register struct fraglist *f; @@ -501,13 +586,15 @@ int i; DCHECK(hp->fd < 0 | hp->fd >= nhdfragls || !hdfragl[hp->fd].nlinks, CONSISTENCY, "bad file descriptor in hdfreefrag"); f = &hdfragl[hp->fd]; + if (!f->writable) + return(0); if (f->nfrags % FRAGBLK == 0) { /* delete empty remnants */ for (j = k = 0; k < f->nfrags; j++, k++) { while (f->fi[k].nrd == 0) if (++k >= f->nfrags) goto endloop; if (k > j) - copystruct(f->fi+j, f->fi+k); + *(f->fi+j) = *(f->fi+k); } endloop: f->nfrags = j; @@ -525,7 +612,7 @@ int i; if (f->fi == NULL) newp = (BEAMI *)malloc((j+FRAGBLK)*sizeof(BEAMI)); else - newp = (BEAMI *)realloc((char *)f->fi, + newp = (BEAMI *)realloc((void *)f->fi, (j+FRAGBLK)*sizeof(BEAMI)); if (newp == NULL) { f->nfrags--; /* graceful failure */ @@ -539,7 +626,7 @@ int i; f->fi[j].nrd = bi->nrd; break; } - copystruct(f->fi+j, f->fi+(j-1)); + *(f->fi+j) = *(f->fi+(j-1)); } /* coalesce adjacent fragments */ /* successors never empty */ @@ -558,22 +645,23 @@ int i; } biglob(hp)->nrd -= bi->nrd; /* tell fragment it's free */ bi->nrd = 0; - bi->fo = 0L; + bi->fo = 0; hdmarkdirty(hp, i); /* assume we'll reallocate */ return(1); } -int -hdfragOK(fd, listlen, listsiz) /* get fragment list status for file */ -int fd; -int *listlen; -register int4 *listsiz; +extern int +hdfragOK( /* get fragment list status for file */ + int fd, + int *listlen, + register int32 *listsiz +) { register struct fraglist *f; register int i; - if (fd < 0 | fd >= nhdfragls || !(f = &hdfragl[fd])->nlinks) + if ((fd < 0) | (fd >= nhdfragls) || !(f = &hdfragl[fd])->nlinks) return(0); /* listless */ if (listlen != NULL) *listlen = f->nfrags; @@ -588,14 +676,15 @@ register int4 *listsiz; } -long -hdallocfrag(fd, nrays) /* allocate a file fragment */ -int fd; -unsigned int4 nrays; +off_t +hdallocfrag( /* allocate a file fragment */ + int fd, + uint32 nrays +) { register struct fraglist *f; register int j; - long nfo; + off_t nfo; if (nrays == 0) return(-1L); @@ -618,17 +707,18 @@ unsigned int4 nrays; int -hdsyncbeam(hp, i) /* sync beam in memory with beam on disk */ -register HOLO *hp; -register int i; +hdsyncbeam( /* sync beam in memory with beam on disk */ + register HOLO *hp, + register int i +) { int fragfreed; - unsigned int4 nrays; + uint32 nrays; unsigned int n; - long nfo; + off_t nfo; /* check file status */ - if (hdfragl[hp->fd].writerr) - return(-1); + if (hdfragl[hp->fd].writable <= 0) + return(hdfragl[hp->fd].writable); DCHECK(i < 1 | i > nbeams(hp), CONSISTENCY, "bad beam index in hdsyncbeam"); /* is current fragment OK? */ @@ -639,17 +729,17 @@ register int i; if (nrays) { /* get and write new fragment */ nfo = hdallocfrag(hp->fd, nrays); errno = 0; - if (lseek(hp->fd, nfo, 0) < 0) + if (lseek(hp->fd, nfo, SEEK_SET) < 0) error(SYSTEM, "cannot seek on holodeck file"); n = hp->bl[i]->nrm * sizeof(RAYVAL); if (write(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) { - hdfragl[hp->fd].writerr++; + hdfragl[hp->fd].writable = -1; hdsync(NULL, 0); /* sync directories */ error(SYSTEM, "write error in hdsyncbeam"); } hp->bi[i].fo = nfo; } else - hp->bi[i].fo = 0L; + hp->bi[i].fo = 0; biglob(hp)->nrd += nrays - hp->bi[i].nrd; hp->bi[i].nrd = nrays; if (!fragfreed) @@ -658,10 +748,11 @@ register int i; } -int -hdfreebeam(hp, i) /* free beam, writing if dirty */ -register HOLO *hp; -register int i; +extern int +hdfreebeam( /* free beam, writing if dirty */ + register HOLO *hp, + register int i +) { int nchanged; @@ -671,7 +762,7 @@ register int i; nchanged += hdfreebeam(hdlist[i], 0); return(nchanged); } - if (hdfragl[hp->fd].writerr) /* check for file error */ + if (hdfragl[hp->fd].writable < 0) /* check for file error */ return(0); if (i == 0) { /* clear entire holodeck */ if (blglob(hp)->nrm == 0) @@ -693,16 +784,17 @@ register int i; if (nchanged) hdsyncbeam(hp, i); /* write new fragment */ blglob(hp)->nrm -= hp->bl[i]->nrm; - free((char *)hp->bl[i]); /* free memory */ + free((void *)hp->bl[i]); /* free memory */ hp->bl[i] = NULL; return(nchanged); } -int -hdkillbeam(hp, i) /* delete beam from holodeck */ -register HOLO *hp; -register int i; +extern int +hdkillbeam( /* delete beam from holodeck */ + register HOLO *hp, + register int i +) { int nchanged; @@ -713,7 +805,7 @@ register int i; return(nchanged); } if (i == 0) { /* clobber entire holodeck */ - if (biglob(hp)->nrd == 0 & blglob(hp)->nrm == 0) + if ((biglob(hp)->nrd == 0) & (blglob(hp)->nrm == 0)) return(0); /* already empty */ nchanged = 0; nchanged = 0; @@ -724,18 +816,20 @@ register int i; CONSISTENCY, "bad beam count in hdkillbeam"); return(nchanged); } - DCHECK(i < 1 | i > nbeams(hp), - CONSISTENCY, "bad beam index to hdkillbeam"); + DCHECK(i < 1 | i > nbeams(hp), CONSISTENCY, + "bad beam index to hdkillbeam"); + DCHECK(!hdfragl[hp->fd].writable, CONSISTENCY, + "hdkillbeam called on read-only holodeck"); if (hp->bl[i] != NULL) { /* free memory */ blglob(hp)->nrm -= nchanged = hp->bl[i]->nrm; - free((char *)hp->bl[i]); + free((void *)hp->bl[i]); hp->bl[i] = NULL; } else nchanged = hp->bi[i].nrd; if (hp->bi[i].nrd && !(hdfragflags&FF_KILL && hdfreefrag(hp,i))) { biglob(hp)->nrd -= hp->bi[i].nrd; /* free failed */ hp->bi[i].nrd = 0; - hp->bi[i].fo = 0L; + hp->bi[i].fo = 0; hdmarkdirty(hp, i); } return(nchanged); @@ -743,11 +837,12 @@ register int i; int -hdlrulist(hb, nents, n, hp) /* add beams from holodeck to LRU list */ -register HDBEAMI *hb; /* beam list */ -int nents; /* current list length */ -int n; /* maximum list length */ -register HOLO *hp; /* section we're adding from */ +hdlrulist( /* add beams from holodeck to LRU list */ + register HDBEAMI *hb, /* beam list */ + int nents, /* current list length */ + int n, /* maximum list length */ + register HOLO *hp /* section we're adding from */ +) { register int i, j; /* insert each beam from hp */ @@ -767,7 +862,7 @@ register HOLO *hp; /* section we're adding from */ hb[j].b = i; break; } - copystruct(hb+j, hb+(j-1)); + *(hb+j) = *(hb+(j-1)); } } return(nents); /* return new list length */ @@ -775,9 +870,10 @@ register HOLO *hp; /* section we're adding from */ int -hdfreecache(pct, honly) /* free up cache space, writing changes */ -int pct; /* maximum percentage to free */ -register HOLO *honly; /* NULL means check all */ +hdfreecache( /* free up cache space, writing changes */ + int pct, /* maximum percentage to free */ + register HOLO *honly /* NULL means check all */ +) { HDBEAMI hb[FREEBEAMS]; int freetarget; @@ -818,15 +914,17 @@ register HOLO *honly; /* NULL means check all */ } -hddone(hp) /* clean up holodeck section and free */ -register HOLO *hp; /* NULL means clean up all */ +extern void +hddone( /* clean up holodeck section and free */ + register HOLO *hp /* NULL means clean up all */ +) { register int i; if (hp == NULL) { /* NULL means clean up everything */ while (hdlist[0] != NULL) hddone(hdlist[0]); - free((char *)hdfragl); + free((void *)hdfragl); hdfragl = NULL; nhdfragls = 0; return; } @@ -841,6 +939,6 @@ register HOLO *hp; /* NULL means clean up all */ i++; break; } - free((char *)hp->bl); /* free beam list */ - free((char *)hp); /* free holodeck struct */ + free((void *)hp->bl); /* free beam list */ + free((void *)hp); /* free holodeck struct */ }