5 |
|
* Radiance holodeck generation controller |
6 |
|
*/ |
7 |
|
|
8 |
+ |
#include <stdio.h> |
9 |
+ |
#include <time.h> |
10 |
|
#include <signal.h> |
11 |
|
#include <sys/stat.h> |
12 |
|
#include <string.h> |
13 |
|
|
14 |
+ |
#include "platform.h" |
15 |
+ |
#include "rterror.h" |
16 |
+ |
#include "resolu.h" |
17 |
|
#include "rholo.h" |
18 |
|
#include "random.h" |
19 |
|
|
69 |
|
|
70 |
|
extern int nowarn; /* turn warnings off? */ |
71 |
|
|
72 |
< |
extern time_t time(); |
72 |
> |
static void onsig(int signo); |
73 |
> |
static void sigdie(int signo, char *msg); |
74 |
> |
static int resfmode(int fd, int mod); |
75 |
> |
static void initrholo(void); |
76 |
> |
static int rholo(void); |
77 |
> |
static void setdefaults(HDGRID *gp); |
78 |
> |
static void creatholo(HDGRID *gp); |
79 |
> |
static gethfunc headline; |
80 |
> |
static void loadholo(void); |
81 |
> |
static void rootname(char *rn, char *fn); |
82 |
> |
static void badvalue(int vc); |
83 |
|
|
84 |
|
|
85 |
< |
main(argc, argv) |
86 |
< |
int argc; |
87 |
< |
char *argv[]; |
85 |
> |
int |
86 |
> |
main( |
87 |
> |
int argc, |
88 |
> |
char *argv[] |
89 |
> |
) |
90 |
|
{ |
91 |
|
int i; |
92 |
|
|
168 |
|
"Usage: %s [-n nprocs][-o disp][-w][-r|-f] output.hdk [control.hif|+|- [VAR=val ..]]\n", |
169 |
|
progname); |
170 |
|
quit(1); |
171 |
+ |
return 1; /* pro forma return */ |
172 |
|
} |
173 |
|
|
174 |
|
|
175 |
< |
void |
176 |
< |
onsig(signo) /* fatal signal */ |
177 |
< |
int signo; |
175 |
> |
static void |
176 |
> |
onsig( /* fatal signal */ |
177 |
> |
int signo |
178 |
> |
) |
179 |
|
{ |
180 |
|
static int gotsig = 0; |
181 |
|
|
193 |
|
} |
194 |
|
|
195 |
|
|
196 |
< |
sigdie(signo, msg) /* set fatal signal */ |
197 |
< |
int signo; |
198 |
< |
char *msg; |
196 |
> |
static void |
197 |
> |
sigdie( /* set fatal signal */ |
198 |
> |
int signo, |
199 |
> |
char *msg |
200 |
> |
) |
201 |
|
{ |
202 |
|
if (signal(signo, onsig) == SIG_IGN) |
203 |
|
signal(signo, SIG_IGN); |
205 |
|
} |
206 |
|
|
207 |
|
|
208 |
< |
int |
209 |
< |
resfmode(fd, mod) /* restrict open file access mode */ |
210 |
< |
int fd, mod; |
208 |
> |
static int |
209 |
> |
resfmode( /* restrict open file access mode */ |
210 |
> |
int fd, |
211 |
> |
int mod |
212 |
> |
) |
213 |
|
{ |
214 |
|
struct stat stbuf; |
215 |
|
/* get original mode */ |
227 |
|
} |
228 |
|
|
229 |
|
|
230 |
< |
initrholo() /* get our holodeck running */ |
230 |
> |
static void |
231 |
> |
initrholo(void) /* get our holodeck running */ |
232 |
|
{ |
233 |
|
extern int global_packet(); |
234 |
|
register int i; |
293 |
|
} |
294 |
|
/* set up signal handling */ |
295 |
|
sigdie(SIGINT, "Interrupt"); |
272 |
– |
sigdie(SIGHUP, "Hangup"); |
296 |
|
sigdie(SIGTERM, "Terminate"); |
297 |
+ |
#ifdef SIGHUP |
298 |
+ |
sigdie(SIGHUP, "Hangup"); |
299 |
+ |
#endif |
300 |
+ |
#ifdef SIGPIPE |
301 |
|
sigdie(SIGPIPE, "Broken pipe"); |
302 |
+ |
#endif |
303 |
+ |
#ifdef SIGALRM |
304 |
|
sigdie(SIGALRM, "Alarm clock"); |
305 |
+ |
#endif |
306 |
|
#ifdef SIGXCPU |
307 |
|
sigdie(SIGXCPU, "CPU limit exceeded"); |
308 |
+ |
#endif |
309 |
+ |
#ifdef SIGXFSZ |
310 |
|
sigdie(SIGXFSZ, "File size exceeded"); |
311 |
|
#endif |
312 |
|
/* protect holodeck file */ |
313 |
< |
orig_mode = resfmode(hdlist[0]->fd, ncprocs>0&force>=0 ? 0 : 0444); |
313 |
> |
orig_mode = resfmode(hdlist[0]->fd, (ncprocs>0) & (force>=0) ? 0 : 0444); |
314 |
|
return; |
315 |
|
memerr: |
316 |
|
error(SYSTEM, "out of memory in initrholo"); |
317 |
|
} |
318 |
|
|
319 |
|
|
320 |
< |
rholo() /* holodeck main loop */ |
320 |
> |
static int |
321 |
> |
rholo(void) /* holodeck main loop */ |
322 |
|
{ |
323 |
|
static long nextfragwarn = 100*(1L<<20); |
324 |
|
static int idle = 0; |
325 |
|
PACKET *pl = NULL, *plend; |
326 |
< |
off_t fsiz; |
326 |
> |
off_t fsiz, fuse; |
327 |
|
int pksiz; |
328 |
|
register PACKET *p; |
329 |
|
time_t t; |
345 |
|
} |
346 |
|
#if FRAGWARN |
347 |
|
if (fsiz >= nextfragwarn && |
348 |
< |
(fsiz-hdfiluse(hdlist[0]->fd,0))/(fsiz/100) > FRAGWARN) { |
348 |
> |
(fsiz-(fuse=hdfiluse(hdlist[0]->fd)))/(fsiz/100) > FRAGWARN) { |
349 |
|
sprintf(errmsg, "holodeck file fragmentation is %.0f%%", |
350 |
< |
100.*(fsiz-hdfiluse(hdlist[0]->fd,1))/fsiz); |
350 |
> |
100.*(fsiz-fuse)/fsiz); |
351 |
|
error(WARNING, errmsg); |
352 |
< |
nextfragwarn = fsiz + (fsiz>>2); /* decent interval */ |
352 |
> |
nextfragwarn = fsiz + (fsiz>>2); |
353 |
|
} |
354 |
|
#endif |
355 |
|
t = time(NULL); /* check time */ |
387 |
|
} |
388 |
|
|
389 |
|
|
390 |
< |
setdefaults(gp) /* set default values */ |
391 |
< |
register HDGRID *gp; |
390 |
> |
static void |
391 |
> |
setdefaults( /* set default values */ |
392 |
> |
register HDGRID *gp |
393 |
> |
) |
394 |
|
{ |
395 |
|
extern char *atos(); |
396 |
|
register int i; |
397 |
|
int n; |
398 |
|
double len[3], d; |
364 |
– |
char buf[64]; |
399 |
|
|
400 |
|
if (!vdef(SECTION)) { |
401 |
|
sprintf(errmsg, "%s must be defined", vnam(SECTION)); |
445 |
|
} |
446 |
|
|
447 |
|
|
448 |
< |
creatholo(gp) /* create a holodeck output file */ |
449 |
< |
HDGRID *gp; |
448 |
> |
static void |
449 |
> |
creatholo( /* create a holodeck output file */ |
450 |
> |
HDGRID *gp |
451 |
> |
) |
452 |
|
{ |
453 |
|
extern char VersionID[]; |
454 |
|
int32 lastloc, nextloc; |
469 |
|
putw(HOLOMAGIC, fp); /* put magic number */ |
470 |
|
fd = dup(fileno(fp)); |
471 |
|
fclose(fp); /* flush and close stdio stream */ |
472 |
< |
lastloc = lseek(fd, (off_t)0, 2); |
472 |
> |
lastloc = lseek(fd, (off_t)0, SEEK_END); |
473 |
|
for (n = vdef(SECTION); n--; gp++) { /* initialize each section */ |
474 |
|
nextloc = 0L; |
475 |
|
write(fd, (char *)&nextloc, sizeof(nextloc)); |
477 |
|
if (!n) |
478 |
|
break; |
479 |
|
nextloc = hdfilen(fd); /* write section pointer */ |
480 |
< |
if (lseek(fd, (off_t)lastloc, 0) < 0) |
480 |
> |
if (lseek(fd, (off_t)lastloc, SEEK_SET) < 0) |
481 |
|
error(SYSTEM, |
482 |
|
"cannot seek on holodeck file in creatholo"); |
483 |
|
write(fd, (char *)&nextloc, sizeof(nextloc)); |
484 |
< |
lseek(fd, (off_t)(lastloc=nextloc), 0); |
484 |
> |
lseek(fd, (off_t)(lastloc=nextloc), SEEK_SET); |
485 |
|
} |
486 |
|
} |
487 |
|
|
488 |
|
|
489 |
< |
int |
490 |
< |
headline(s) /* process information header line */ |
491 |
< |
char *s; |
489 |
> |
static int |
490 |
> |
headline( /* process information header line */ |
491 |
> |
char *s, |
492 |
> |
void *p |
493 |
> |
) |
494 |
|
{ |
495 |
|
extern char FMTSTR[]; |
496 |
|
register char *cp; |
514 |
|
} |
515 |
|
|
516 |
|
|
517 |
< |
loadholo() /* start loading a holodeck from fname */ |
517 |
> |
static void |
518 |
> |
loadholo(void) /* start loading a holodeck from fname */ |
519 |
|
{ |
520 |
|
FILE *fp; |
521 |
|
int fd; |
522 |
|
int n; |
523 |
|
int32 nextloc; |
524 |
|
|
525 |
< |
if (ncprocs > 0 & force >= 0) |
525 |
> |
if ((ncprocs > 0) & (force >= 0)) |
526 |
|
fp = fopen(hdkfile, "r+"); |
527 |
|
else |
528 |
|
fp = NULL; |
551 |
|
fd = dup(fileno(fp)); |
552 |
|
fclose(fp); /* done with stdio */ |
553 |
|
for (n = 0; nextloc > 0L; n++) { /* initialize each section */ |
554 |
< |
lseek(fd, (off_t)nextloc, 0); |
554 |
> |
lseek(fd, (off_t)nextloc, SEEK_SET); |
555 |
|
read(fd, (char *)&nextloc, sizeof(nextloc)); |
556 |
|
hdinit(fd, NULL); |
557 |
|
} |
563 |
|
} |
564 |
|
|
565 |
|
|
566 |
< |
done_packets(pl) /* handle finished packets */ |
567 |
< |
PACKET *pl; |
566 |
> |
extern void |
567 |
> |
done_packets( /* handle finished packets */ |
568 |
> |
PACKET *pl |
569 |
> |
) |
570 |
|
{ |
571 |
|
static int n2flush = 0; |
572 |
|
register PACKET *p; |
598 |
|
} |
599 |
|
|
600 |
|
|
601 |
< |
rootname(rn, fn) /* remove tail from end of fn */ |
602 |
< |
register char *rn, *fn; |
601 |
> |
static void |
602 |
> |
rootname( /* remove tail from end of fn */ |
603 |
> |
register char *rn, |
604 |
> |
register char *fn |
605 |
> |
) |
606 |
|
{ |
607 |
|
char *tp, *dp; |
608 |
|
|
609 |
< |
for (tp = NULL, dp = rn; *rn = *fn++; rn++) |
609 |
> |
for (tp = NULL, dp = rn; (*rn = *fn++); rn++) { |
610 |
|
if (*rn == '/') |
611 |
|
dp = rn; |
612 |
|
else if (*rn == '.') |
613 |
|
tp = rn; |
614 |
+ |
} |
615 |
|
if (tp != NULL && tp > dp) |
616 |
|
*tp = '\0'; |
617 |
|
} |
618 |
|
|
619 |
|
|
620 |
< |
badvalue(vc) /* report bad variable value and exit */ |
621 |
< |
int vc; |
620 |
> |
static void |
621 |
> |
badvalue( /* report bad variable value and exit */ |
622 |
> |
int vc |
623 |
> |
) |
624 |
|
{ |
625 |
|
sprintf(errmsg, "bad value for variable '%s'", vnam(vc)); |
626 |
|
error(USER, errmsg); |
656 |
|
if (hdlist[0] != NULL) { /* close holodeck */ |
657 |
|
if (nprocs > 0) |
658 |
|
status = done_rtrace(); /* calls hdsync() */ |
659 |
< |
if (ncprocs > 0 & force >= 0 && vdef(REPORT)) { |
659 |
> |
if ((ncprocs > 0) & (force >= 0) && vdef(REPORT)) { |
660 |
|
off_t fsiz, fuse; |
661 |
|
fsiz = hdfilen(hdlist[0]->fd); |
662 |
< |
fuse = hdfiluse(hdlist[0]->fd, 1); |
662 |
> |
fuse = hdfiluse(hdlist[0]->fd); |
663 |
|
fprintf(stderr, |
664 |
|
"%s: %.1f Mbyte holodeck file, %.1f%% fragmentation\n", |
665 |
|
hdkfile, fsiz/(1024.*1024.), |