ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/hd/holofile.c

Comparing ray/src/hd/holofile.c (file contents):
Revision 3.40 by gwlarson, Fri Mar 12 09:37:48 1999 UTC vs.
Revision 3.42 by greg, Sat Feb 22 02:07:24 2003 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1999 Silicon Graphics, Inc. */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ SGI";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Routines for managing holodeck files
6		*
#	Line 52 | Line 49 | HOLO   *hdlist[HDMAX+1];       /* holodeck pointers (NULL term
49
50		static struct fraglist {
51		short   nlinks;         /* number of holodeck sections using us */
52	<	short   writerr;        /* write error encountered */
52	>	short   writable;       /* 0 read-only, <0 write error encountered */
53		int     nfrags;         /* number of known fragments */
54		BEAMI   *fi;            /* fragments, descending file position */
55		long    flen;           /* last known file length */
#	Line 81 | Line 78 | HDGRID *hproto;
78		/* allocate and clear beam list */
79		hp->bl = (BEAM **)malloc((nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
80		if (hp->bl == NULL) {
81	<	free((char *)hp);
81	>	free((void *)hp);
82		return(NULL);
83		}
84		bzero((char *)hp->bl, (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
#	Line 119 | Line 116 | char   *rout;
116		}
117
118
119	<	hdattach(fd)            /* start tracking file fragments for some section */
119	>	hdattach(fd, wr)        /* start tracking file fragments for some section */
120		register int    fd;
121	+	int     wr;
122		{
123		if (fd >= nhdfragls) {
124		hdfragl = (struct fraglist *)hdrealloc((char *)hdfragl,
#	Line 130 | Line 128 | register int   fd;
128		nhdfragls = fd+1;
129		}
130		hdfragl[fd].nlinks++;
131	<	hdfragl[fd].flen = lseek(fd, 0L, 2);    /* get file length */
131	>	hdfragl[fd].writable = wr;              /* set writable flag */
132	>	hdfragl[fd].flen = lseek(fd, (off_t)0L, 2);     /* get file length */
133		}
134
135
#	Line 143 | Line 142 | register int   fd;
142		if (fd < 0 | fd >= nhdfragls || !hdfragl[fd].nlinks)
143		return;
144		if (!--hdfragl[fd].nlinks && hdfragl[fd].nfrags) {
145	<	free((char *)hdfragl[fd].fi);
145	>	free((void *)hdfragl[fd].fi);
146		hdfragl[fd].fi = NULL;
147		hdfragl[fd].nfrags = 0;
148		}
#	Line 157 | Line 156 | HDGRID *hproto;                /* holodeck section grid */
156		{
157		long    rtrunc;
158		long    fpos;
159	+	int     writable;
160		register HOLO   *hp;
161		register int    n;
162		/* prepare for system errors */
163		errno = 0;
164	<	if ((fpos = lseek(fd, 0L, 1)) < 0)
164	>	if ((fpos = lseek(fd, (off_t)0L, 1)) < 0)
165		error(SYSTEM, "cannot determine holodeck file position");
166		if (hproto == NULL) {           /* assume we're loading it */
167		HDGRID  hpr;
#	Line 182 | Line 182 | HDGRID *hproto;                /* holodeck section grid */
182		error(WARNING, "dirty holodeck section");
183		break;
184		}
185	<	} else {                        /* assume we're creating it */
185	>	/* check writability */
186	>	if (fd < nhdfragls && hdfragl[fd].nlinks)
187	>	writable = hdfragl[fd].writable;
188	>	else
189	>	writable = lseek(fd, (off_t)fpos, 0) == fpos &&
190	>	write(fd, (char *)hp, sizeof(HDGRID)) ==
191	>	sizeof(HDGRID);
192	>	} else {                        /* else assume we're creating it */
193		if ((hp = hdalloc(hproto)) == NULL)
194		goto memerr;
195		/* write header and skeleton */
#	Line 191 | Line 198 | HDGRID *hproto;                /* holodeck section grid */
198		sizeof(HDGRID) ||
199		write(fd, (char *)(hp->bi+1), n) != n)
200		error(SYSTEM, "cannot write header to holodeck file");
201	+	writable = 1;
202		}
203		hp->fd = fd;
204		hp->dirty = 0;
205		biglob(hp)->fo = fpos + sizeof(HDGRID);
206		/* start tracking fragments */
207	<	hdattach(fd);
207	>	hdattach(fd, writable);
208		/* check rays on disk */
209		fpos = hdfilen(fd);
210		biglob(hp)->nrd = rtrunc = 0;
#	Line 234 | Line 242 | int    i;
242		register int    j;
243
244		if (!hp->dirty++) {                     /* write smudge first time */
245	<	if (lseek(hp->fd, biglob(hp)->fo+(i-1)*sizeof(BEAMI), 0) < 0
245	>	if (lseek(hp->fd, (off_t)(biglob(hp)->fo+(i-1)*sizeof(BEAMI)), 0) < 0
246		|| write(hp->fd, (char *)&smudge,
247		sizeof(BEAMI)) != sizeof(BEAMI))
248		error(SYSTEM, "seek/write error in hdmarkdirty");
#	Line 297 | Line 305 | int    all;
305		return(0);
306		errno = 0;                      /* write dirty segments */
307		for (j = 0; j < hp->dirty; j++) {
308	<	if (lseek(hp->fd, biglob(hp)->fo +
309	<	(hp->dirseg[j].s-1)*sizeof(BEAMI), 0) < 0)
308	>	if (lseek(hp->fd, (off_t)(biglob(hp)->fo +
309	>	(hp->dirseg[j].s-1)*sizeof(BEAMI)), 0) < 0)
310		error(SYSTEM, "cannot seek on holodeck file");
311		n = hp->dirseg[j].n * sizeof(BEAMI);
312		if (write(hp->fd, (char *)(hp->bi+hp->dirseg[j].s), n) != n)
#	Line 347 | Line 355 | int    fd;
355		if (fd < 0)
356		return(-1);
357		if (fd >= nhdfragls || !hdfragl[fd].nlinks) {
358	<	if ((fpos = lseek(fd, 0L, 1)) < 0)
358	>	if ((fpos = lseek(fd, (off_t)0L, 1)) < 0)
359		return(-1);
360	<	flen = lseek(fd, 0L, 2);
361	<	lseek(fd, fpos, 0);
360	>	flen = lseek(fd, (off_t)0L, 2);
361	>	lseek(fd, (off_t)fpos, 0);
362		return(flen);
363		}
364		return(hdfragl[fd].flen);
#	Line 405 | Line 413 | int    nr;                     /* number of new rays desired */
413		blglob(hp)->nrm += n;
414		if ((n = hp->bl[i]->nrm = hp->bi[i].nrd)) {
415		errno = 0;
416	<	if (lseek(hp->fd, hp->bi[i].fo, 0) < 0)
416	>	if (lseek(hp->fd, (off_t)hp->bi[i].fo, 0) < 0)
417		error(SYSTEM, "seek error on holodeck file");
418		n *= sizeof(RAYVAL);
419		if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
#	Line 444 | Line 452 | register int   i;
452		hp->bl[i] = (BEAM *)hdrealloc(NULL, hdbsiz(n), "hdgetbeam");
453		blglob(hp)->nrm += hp->bl[i]->nrm = n;
454		errno = 0;
455	<	if (lseek(hp->fd, hp->bi[i].fo, 0) < 0)
455	>	if (lseek(hp->fd, (off_t)hp->bi[i].fo, 0) < 0)
456		error(SYSTEM, "seek error on holodeck file");
457		n *= sizeof(RAYVAL);
458		if (read(hp->fd, (char *)hdbray(hp->bl[i]), n) != n)
#	Line 535 | Line 543 | int    i;
543		DCHECK(hp->fd < 0 | hp->fd >= nhdfragls || !hdfragl[hp->fd].nlinks,
544		CONSISTENCY, "bad file descriptor in hdfreefrag");
545		f = &hdfragl[hp->fd];
546	+	if (!f->writable)
547	+	return(0);
548		if (f->nfrags % FRAGBLK == 0) { /* delete empty remnants */
549		for (j = k = 0; k < f->nfrags; j++, k++) {
550		while (f->fi[k].nrd == 0)
#	Line 661 | Line 671 | register int   i;
671		unsigned int    n;
672		long    nfo;
673		/* check file status */
674	<	if (hdfragl[hp->fd].writerr)
675	<	return(-1);
674	>	if (hdfragl[hp->fd].writable <= 0)
675	>	return(hdfragl[hp->fd].writable);
676		DCHECK(i < 1 | i > nbeams(hp),
677		CONSISTENCY, "bad beam index in hdsyncbeam");
678		/* is current fragment OK? */
#	Line 673 | Line 683 | register int   i;
683		if (nrays) {                    /* get and write new fragment */
684		nfo = hdallocfrag(hp->fd, nrays);
685		errno = 0;
686	<	if (lseek(hp->fd, nfo, 0) < 0)
686	>	if (lseek(hp->fd, (off_t)nfo, 0) < 0)
687		error(SYSTEM, "cannot seek on holodeck file");
688		n = hp->bl[i]->nrm * sizeof(RAYVAL);
689		if (write(hp->fd, (char *)hdbray(hp->bl[i]), n) != n) {
690	<	hdfragl[hp->fd].writerr++;
690	>	hdfragl[hp->fd].writable = -1;
691		hdsync(NULL, 0);        /* sync directories */
692		error(SYSTEM, "write error in hdsyncbeam");
693		}
#	Line 705 | Line 715 | register int   i;
715		nchanged += hdfreebeam(hdlist[i], 0);
716		return(nchanged);
717		}
718	<	if (hdfragl[hp->fd].writerr)    /* check for file error */
718	>	if (hdfragl[hp->fd].writable < 0)       /* check for file error */
719		return(0);
720		if (i == 0) {                   /* clear entire holodeck */
721		if (blglob(hp)->nrm == 0)
#	Line 727 | Line 737 | register int   i;
737		if (nchanged)
738		hdsyncbeam(hp, i);              /* write new fragment */
739		blglob(hp)->nrm -= hp->bl[i]->nrm;
740	<	free((char *)hp->bl[i]);                /* free memory */
740	>	free((void *)hp->bl[i]);                /* free memory */
741		hp->bl[i] = NULL;
742		return(nchanged);
743		}
#	Line 758 | Line 768 | register int   i;
768		CONSISTENCY, "bad beam count in hdkillbeam");
769		return(nchanged);
770		}
771	<	DCHECK(i < 1 | i > nbeams(hp),
772	<	CONSISTENCY, "bad beam index to hdkillbeam");
771	>	DCHECK(i < 1 | i > nbeams(hp), CONSISTENCY,
772	>	"bad beam index to hdkillbeam");
773	>	DCHECK(!hdfragl[hp->fd].writable, CONSISTENCY,
774	>	"hdkillbeam called on read-only holodeck");
775		if (hp->bl[i] != NULL) {        /* free memory */
776		blglob(hp)->nrm -= nchanged = hp->bl[i]->nrm;
777	<	free((char *)hp->bl[i]);
777	>	free((void *)hp->bl[i]);
778		hp->bl[i] = NULL;
779		} else
780		nchanged = hp->bi[i].nrd;
#	Line 860 | Line 872 | register HOLO  *hp;            /* NULL means clean up all */
872		if (hp == NULL) {               /* NULL means clean up everything */
873		while (hdlist[0] != NULL)
874		hddone(hdlist[0]);
875	<	free((char *)hdfragl);
875	>	free((void *)hdfragl);
876		hdfragl = NULL; nhdfragls = 0;
877		return;
878		}
#	Line 875 | Line 887 | register HOLO  *hp;            /* NULL means clean up all */
887		i++;
888		break;
889		}
890	<	free((char *)hp->bl);           /* free beam list */
891	<	free((char *)hp);               /* free holodeck struct */
890	>	free((void *)hp->bl);           /* free beam list */
891	>	free((void *)hp);               /* free holodeck struct */
892		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)