ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holofile.c
(Generate patch)

Comparing ray/src/hd/holofile.c (file contents):
Revision 3.39 by gwlarson, Tue Mar 9 08:40:11 1999 UTC vs.
Revision 3.43 by greg, Wed Apr 23 00:52:33 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 61 | Line 58 | static struct fraglist {
58   static int      nhdfragls;      /* size of hdfragl array */
59  
60  
61 + HOLO *
62 + hdalloc(hproto)         /* allocate and set holodeck section based on grid */
63 + HDGRID  *hproto;
64 + {
65 +        HOLO    hdhead;
66 +        register HOLO   *hp;
67 +        int     n;
68 +                                /* copy grid to temporary header */
69 +        bcopy((char *)hproto, (char *)&hdhead, sizeof(HDGRID));
70 +                                /* compute grid vectors and sizes */
71 +        hdcompgrid(&hdhead);
72 +                                /* allocate header with directory */
73 +        n = sizeof(HOLO)+nbeams(&hdhead)*sizeof(BEAMI);
74 +        if ((hp = (HOLO *)malloc(n)) == NULL)
75 +                return(NULL);
76 +                                /* copy header information */
77 +        copystruct(hp, &hdhead);
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((void *)hp);
82 +                return(NULL);
83 +        }
84 +        bzero((char *)hp->bl, (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
85 +        hp->bl[0] = (BEAM *)(hp->bl+nbeams(hp)+1);      /* set blglob(hp) */
86 +        hp->fd = -1;
87 +        hp->dirty = 0;
88 +        hp->priv = NULL;
89 +                                /* clear beam directory */
90 +        bzero((char *)hp->bi, (nbeams(hp)+1)*sizeof(BEAMI));
91 +        return(hp);             /* all is well */
92 + }
93 +
94 +
95   char *
96   hdrealloc(ptr, siz, rout)       /* (re)allocate memory, retry then error */
97   char    *ptr;
# Line 70 | Line 101 | char   *rout;
101          register char   *newp;
102                                          /* call malloc/realloc */
103          if (ptr == NULL) newp = (char *)malloc(siz);
104 <        else newp = (char *)realloc(ptr, siz);
104 >        else newp = (char *)realloc((void *)ptr, siz);
105                                          /* check success */
106          if (newp == NULL && rout != NULL) {
107                  hdfreecache(25, NULL);  /* free some memory */
# Line 85 | 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 96 | 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 109 | 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 123 | 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 148 | 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 157 | 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 200 | 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 263 | 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 313 | 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 371 | 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 410 | 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 501 | 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 525 | Line 569 | int    i;
569                  if (f->fi == NULL)
570                          newp = (BEAMI *)malloc((j+FRAGBLK)*sizeof(BEAMI));
571                  else
572 <                        newp = (BEAMI *)realloc((char *)f->fi,
572 >                        newp = (BEAMI *)realloc((void *)f->fi,
573                                          (j+FRAGBLK)*sizeof(BEAMI));
574                  if (newp == NULL) {
575                          f->nfrags--;    /* graceful failure */
# Line 627 | 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 639 | 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 671 | 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 693 | 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 724 | 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 826 | 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 841 | 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
> Changed lines