![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to savecore.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc|
Return to savecore.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc |
1.1 root 1: /*
2: * Copyright (c) 1980,1986 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: char copyright[] =
9: "@(#) Copyright (c) 1980,1986 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)savecore.c 5.8 (Berkeley) 5/26/86";
15: #endif not lint
16:
17: /*
18: * savecore
19: */
20:
21: #include <stdio.h>
22: #include <nlist.h>
23: #include <sys/param.h>
24: #include <sys/dir.h>
25: #include <sys/stat.h>
26: #include <sys/fs.h>
27: #include <sys/time.h>
28: #include <sys/file.h>
29: #include <sys/syslog.h>
30:
31: #define DAY (60L*60L*24L)
32: #define LEEWAY (3*DAY)
33:
34: #define eq(a,b) (!strcmp(a,b))
35: #ifdef vax
36: #define ok(number) ((number)&0x7fffffff)
37: #else
38: #define ok(number) (number)
39: #endif
40:
41: struct nlist current_nl[] = { /* namelist for currently running system */
42: #define X_DUMPDEV 0
43: { "_dumpdev" },
44: #define X_DUMPLO 1
45: { "_dumplo" },
46: #define X_TIME 2
47: { "_time" },
48: #define X_DUMPSIZE 3
49: { "_dumpsize" },
50: #define X_VERSION 4
51: { "_version" },
52: #define X_PANICSTR 5
53: { "_panicstr" },
54: #define X_DUMPMAG 6
55: { "_dumpmag" },
56: { "" },
57: };
58:
59: struct nlist dump_nl[] = { /* name list for dumped system */
60: { "_dumpdev" }, /* entries MUST be the same as */
61: { "_dumplo" }, /* those in current_nl[] */
62: { "_time" },
63: { "_dumpsize" },
64: { "_version" },
65: { "_panicstr" },
66: { "_dumpmag" },
67: { "" },
68: };
69:
70: char *system;
71: char *dirname; /* directory to save dumps in */
72: char *ddname; /* name of dump device */
73: char *find_dev();
74: dev_t dumpdev; /* dump device */
75: time_t dumptime; /* time the dump was taken */
76: int dumplo; /* where dump starts on dumpdev */
77: int dumpsize; /* amount of memory dumped */
78: int dumpmag; /* magic number in dump */
79: time_t now; /* current date */
80: char *path();
81: char *malloc();
82: char *ctime();
83: char vers[80];
84: char core_vers[80];
85: char panic_mesg[80];
86: int panicstr;
87: off_t lseek();
88: off_t Lseek();
89: int Verbose;
90: extern int errno;
91:
92: main(argc, argv)
93: char **argv;
94: int argc;
95: {
96: char *cp;
97:
98: argc--, argv++;
99: while (argc > 0 && argv[0][0] == '-') {
100: for (cp = &argv[0][1]; *cp; cp++) switch (*cp) {
101:
102: case 'v':
103: Verbose++;
104: break;
105:
106: default:
107: usage:
108: fprintf(stderr,
109: "usage: savecore [-v] dirname [ system ]\n");
110: exit(1);
111: }
112: argc--, argv++;
113: }
114: if (argc != 1 && argc != 2)
115: goto usage;
116: dirname = argv[0];
117: if (argc == 2)
118: system = argv[1];
119: openlog("savecore", LOG_ODELAY, LOG_AUTH);
120: if (access(dirname, W_OK) < 0) {
121: int oerrno = errno;
122:
123: perror(dirname);
124: errno = oerrno;
125: syslog(LOG_ERR, "%s: %m", dirname);
126: exit(1);
127: }
128: read_kmem();
129: if (!dump_exists()) {
130: if (Verbose)
131: fprintf(stderr, "savecore: No dump exists.\n");
132: exit(0);
133: }
134: (void) time(&now);
135: check_kmem();
136: if (panicstr)
137: syslog(LOG_CRIT, "reboot after panic: %s", panic_mesg);
138: else
139: syslog(LOG_CRIT, "reboot");
140: if (!get_crashtime() || !check_space())
141: exit(1);
142: save_core();
143: clear_dump();
144: exit(0);
145: }
146:
147: dump_exists()
148: {
149: register int dumpfd;
150: int word;
151:
152: dumpfd = Open(ddname, O_RDONLY);
153: Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
154: Read(dumpfd, (char *)&word, sizeof (word));
155: close(dumpfd);
156: if (Verbose && word != dumpmag) {
157: printf("dumplo = %d (%d bytes)\n", dumplo/DEV_BSIZE, dumplo);
158: printf("magic number mismatch: %x != %x\n", word, dumpmag);
159: }
160: return (word == dumpmag);
161: }
162:
163: clear_dump()
164: {
165: register int dumpfd;
166: int zero = 0;
167:
168: dumpfd = Open(ddname, O_WRONLY);
169: Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
170: Write(dumpfd, (char *)&zero, sizeof (zero));
171: close(dumpfd);
172: }
173:
174: char *
175: find_dev(dev, type)
176: register dev_t dev;
177: register int type;
178: {
179: register DIR *dfd = opendir("/dev");
180: struct direct *dir;
181: struct stat statb;
182: static char devname[MAXPATHLEN + 1];
183: char *dp;
184:
185: strcpy(devname, "/dev/");
186: while ((dir = readdir(dfd))) {
187: strcpy(devname + 5, dir->d_name);
188: if (stat(devname, &statb)) {
189: perror(devname);
190: continue;
191: }
192: if ((statb.st_mode&S_IFMT) != type)
193: continue;
194: if (dev == statb.st_rdev) {
195: closedir(dfd);
196: dp = malloc(strlen(devname)+1);
197: strcpy(dp, devname);
198: return (dp);
199: }
200: }
201: closedir(dfd);
202: fprintf(stderr, "Can't find device %d/%d\n", major(dev), minor(dev));
203: syslog(LOG_ERR, "Can't find device %d/%d\n", major(dev), minor(dev));
204: exit(1);
205: /*NOTREACHED*/
206: }
207:
208: int cursyms[] =
209: { X_DUMPDEV, X_DUMPLO, X_VERSION, X_DUMPMAG, -1 };
210: int dumpsyms[] =
211: { X_TIME, X_DUMPSIZE, X_VERSION, X_PANICSTR, X_DUMPMAG, -1 };
212: read_kmem()
213: {
214: register char *cp;
215: FILE *fp;
216: char *dump_sys;
217: int kmem, i;
218:
219: dump_sys = system ? system : "/vmunix";
220: nlist("/vmunix", current_nl);
221: nlist(dump_sys, dump_nl);
222: /*
223: * Some names we need for the currently running system,
224: * others for the system that was running when the dump was made.
225: * The values obtained from the current system are used
226: * to look for things in /dev/kmem that cannot be found
227: * in the dump_sys namelist, but are presumed to be the same
228: * (since the disk partitions are probably the same!)
229: */
230: for (i = 0; cursyms[i] != -1; i++)
231: if (current_nl[cursyms[i]].n_value == 0) {
232: fprintf(stderr, "/vmunix: %s not in namelist",
233: current_nl[cursyms[i]].n_name);
234: syslog(LOG_ERR, "/vmunix: %s not in namelist",
235: current_nl[cursyms[i]].n_name);
236: exit(1);
237: }
238: for (i = 0; dumpsyms[i] != -1; i++)
239: if (dump_nl[dumpsyms[i]].n_value == 0) {
240: fprintf(stderr, "%s: %s not in namelist", dump_sys,
241: dump_nl[dumpsyms[i]].n_name);
242: syslog(LOG_ERR, "%s: %s not in namelist", dump_sys,
243: dump_nl[dumpsyms[i]].n_name);
244: exit(1);
245: }
246: kmem = Open("/dev/kmem", O_RDONLY);
247: Lseek(kmem, (long)current_nl[X_DUMPDEV].n_value, L_SET);
248: Read(kmem, (char *)&dumpdev, sizeof (dumpdev));
249: Lseek(kmem, (long)current_nl[X_DUMPLO].n_value, L_SET);
250: Read(kmem, (char *)&dumplo, sizeof (dumplo));
251: Lseek(kmem, (long)current_nl[X_DUMPMAG].n_value, L_SET);
252: Read(kmem, (char *)&dumpmag, sizeof (dumpmag));
253: dumplo *= DEV_BSIZE;
254: ddname = find_dev(dumpdev, S_IFBLK);
255: fp = fdopen(kmem, "r");
256: if (fp == NULL) {
257: syslog(LOG_ERR, "Couldn't fdopen kmem");
258: exit(1);
259: }
260: if (system)
261: return;
262: fseek(fp, (long)current_nl[X_VERSION].n_value, L_SET);
263: fgets(vers, sizeof (vers), fp);
264: fclose(fp);
265: }
266:
267: check_kmem()
268: {
269: FILE *fp;
270: register char *cp;
271:
272: fp = fopen(ddname, "r");
273: if (fp == NULL) {
274: int oerrno = errno;
275:
276: perror(ddname);
277: errno = oerrno;
278: syslog(LOG_ERR, "%s: %m", ddname);
279: exit(1);
280: }
281: fseek(fp, (off_t)(dumplo+ok(dump_nl[X_VERSION].n_value)), L_SET);
282: fgets(core_vers, sizeof (core_vers), fp);
283: fclose(fp);
284: if (!eq(vers, core_vers) && system == 0)
285: fprintf(stderr,
286: "Warning: vmunix version mismatch:\n\t%sand\n\t%s",
287: vers, core_vers);
288: syslog(LOG_WARNING,
289: "Warning: vmunix version mismatch: %s and %s",
290: vers, core_vers);
291: fp = fopen(ddname, "r");
292: fseek(fp, (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), L_SET);
293: fread((char *)&panicstr, sizeof (panicstr), 1, fp);
294: if (panicstr) {
295: fseek(fp, dumplo + ok(panicstr), L_SET);
296: cp = panic_mesg;
297: do
298: *cp = getc(fp);
299: while (*cp++);
300: }
301: fclose(fp);
302: }
303:
304: get_crashtime()
305: {
306: int dumpfd;
307: time_t clobber = (time_t)0;
308:
309: dumpfd = Open(ddname, O_RDONLY);
310: Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), L_SET);
311: Read(dumpfd, (char *)&dumptime, sizeof dumptime);
312: close(dumpfd);
313: if (dumptime == 0) {
314: if (Verbose)
315: printf("Dump time not found.\n");
316: return (0);
317: }
318: printf("System went down at %s", ctime(&dumptime));
319: if (dumptime < now - LEEWAY || dumptime > now + LEEWAY) {
320: printf("dump time is unreasonable\n");
321: return (0);
322: }
323: return (1);
324: }
325:
326: char *
327: path(file)
328: char *file;
329: {
330: register char *cp = malloc(strlen(file) + strlen(dirname) + 2);
331:
332: (void) strcpy(cp, dirname);
333: (void) strcat(cp, "/");
334: (void) strcat(cp, file);
335: return (cp);
336: }
337:
338: check_space()
339: {
340: struct stat dsb;
341: register char *ddev;
342: int dfd, spacefree;
343: struct fs fs;
344:
345: if (stat(dirname, &dsb) < 0) {
346: int oerrno = errno;
347:
348: perror(dirname);
349: errno = oerrno;
350: syslog(LOG_ERR, "%s: %m", dirname);
351: exit(1);
352: }
353: ddev = find_dev(dsb.st_dev, S_IFBLK);
354: dfd = Open(ddev, O_RDONLY);
355: Lseek(dfd, (long)(SBLOCK * DEV_BSIZE), L_SET);
356: Read(dfd, (char *)&fs, sizeof (fs));
357: close(dfd);
358: spacefree = freespace(&fs, fs.fs_minfree) * fs.fs_fsize / 1024;
359: if (spacefree < read_number("minfree")) {
360: printf("Dump omitted, not enough space on device");
361: syslog(LOG_WARNING, "Dump omitted, not enough space on device");
362: return (0);
363: }
364: if (freespace(&fs, fs.fs_minfree) < 0) {
365: printf("Dump performed, but free space threshold crossed");
366: syslog(LOG_WARNING,
367: "Dump performed, but free space threshold crossed");
368: }
369: return (1);
370: }
371:
372: read_number(fn)
373: char *fn;
374: {
375: char lin[80];
376: register FILE *fp;
377:
378: fp = fopen(path(fn), "r");
379: if (fp == NULL)
380: return (0);
381: if (fgets(lin, 80, fp) == NULL) {
382: fclose(fp);
383: return (0);
384: }
385: fclose(fp);
386: return (atoi(lin));
387: }
388:
389: #define BUFPAGES (256*1024/NBPG) /* 1/4 Mb */
390:
391: save_core()
392: {
393: register int n;
394: register char *cp;
395: register int ifd, ofd, bounds;
396: register FILE *fp;
397:
398: cp = malloc(BUFPAGES*NBPG);
399: if (cp == 0) {
400: fprintf(stderr, "savecore: Can't allocate i/o buffer.\n");
401: return;
402: }
403: bounds = read_number("bounds");
404: ifd = Open(system?system:"/vmunix", O_RDONLY);
405: sprintf(cp, "vmunix.%d", bounds);
406: ofd = Create(path(cp), 0644);
407: while((n = Read(ifd, cp, BUFSIZ)) > 0)
408: Write(ofd, cp, n);
409: close(ifd);
410: close(ofd);
411: ifd = Open(ddname, O_RDONLY);
412: Lseek(ifd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), L_SET);
413: Read(ifd, (char *)&dumpsize, sizeof (dumpsize));
414: sprintf(cp, "vmcore.%d", bounds);
415: ofd = Create(path(cp), 0644);
416: Lseek(ifd, (off_t)dumplo, L_SET);
417: printf("Saving %d bytes of image in vmcore.%d\n", NBPG*dumpsize,
418: bounds);
419: syslog(LOG_NOTICE, "Saving %d bytes of image in vmcore.%d\n",
420: NBPG*dumpsize, bounds);
421: while (dumpsize > 0) {
422: n = Read(ifd, cp,
423: (dumpsize > BUFPAGES ? BUFPAGES : dumpsize) * NBPG);
424: if (n == 0) {
425: syslog(LOG_WARNING,
426: "WARNING: vmcore may be incomplete\n");
427: printf("WARNING: vmcore may be incomplete\n");
428: break;
429: }
430: Write(ofd, cp, n);
431: dumpsize -= n/NBPG;
432: }
433: close(ifd);
434: close(ofd);
435: fp = fopen(path("bounds"), "w");
436: fprintf(fp, "%d\n", bounds+1);
437: fclose(fp);
438: free(cp);
439: }
440:
441: /*
442: * Versions of std routines that exit on error.
443: */
444: Open(name, rw)
445: char *name;
446: int rw;
447: {
448: int fd;
449:
450: fd = open(name, rw);
451: if (fd < 0) {
452: int oerrno = errno;
453:
454: perror(name);
455: errno = oerrno;
456: syslog(LOG_ERR, "%s: %m", name);
457: exit(1);
458: }
459: return (fd);
460: }
461:
462: Read(fd, buff, size)
463: int fd, size;
464: char *buff;
465: {
466: int ret;
467:
468: ret = read(fd, buff, size);
469: if (ret < 0) {
470: int oerrno = errno;
471:
472: perror("read");
473: errno = oerrno;
474: syslog(LOG_ERR, "read: %m");
475: exit(1);
476: }
477: return (ret);
478: }
479:
480: off_t
481: Lseek(fd, off, flag)
482: int fd, flag;
483: long off;
484: {
485: long ret;
486:
487: ret = lseek(fd, off, flag);
488: if (ret == -1) {
489: int oerrno = errno;
490:
491: perror("lseek");
492: errno = oerrno;
493: syslog(LOG_ERR, "lseek: %m");
494: exit(1);
495: }
496: return (ret);
497: }
498:
499: Create(file, mode)
500: char *file;
501: int mode;
502: {
503: register int fd;
504:
505: fd = creat(file, mode);
506: if (fd < 0) {
507: int oerrno = errno;
508:
509: perror(file);
510: errno = oerrno;
511: syslog(LOG_ERR, "%s: %m", file);
512: exit(1);
513: }
514: return (fd);
515: }
516:
517: Write(fd, buf, size)
518: int fd, size;
519: char *buf;
520: {
521:
522: if (write(fd, buf, size) < size) {
523: int oerrno = errno;
524:
525: perror("write");
526: errno = oerrno;
527: syslog(LOG_ERR, "write: %m");
528: exit(1);
529: }
530: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.