1 /*-
2 * Copyright (c) 1986, 1992, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * %sccs.include.redist.c%
6 */
7
8 #ifndef lint
9 static char copyright[] =
10 "@(#) Copyright (c) 1986, 1992, 1993\n\
11 The Regents of the University of California. All rights reserved.\n";
12 #endif /* not lint */
13
14 #ifndef lint
15 static char sccsid[] = "@(#)savecore.c 8.5 (Berkeley) 04/28/95";
16 #endif /* not lint */
17
18 #include <sys/param.h>
19 #include <sys/stat.h>
20 #include <sys/mount.h>
21 #include <sys/syslog.h>
22 #include <sys/time.h>
23
24 #include <dirent.h>
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <nlist.h>
28 #include <paths.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <tzfile.h>
33 #include <unistd.h>
34
35 #define ok(number) ((number) - KERNBASE)
36
37 struct nlist current_nl[] = { /* Namelist for currently running system. */
38 #define X_DUMPDEV 0
39 { "_dumpdev" },
40 #define X_DUMPLO 1
41 { "_dumplo" },
42 #define X_TIME 2
43 { "_time" },
44 #define X_DUMPSIZE 3
45 { "_dumpsize" },
46 #define X_VERSION 4
47 { "_version" },
48 #define X_PANICSTR 5
49 { "_panicstr" },
50 #define X_DUMPMAG 6
51 { "_dumpmag" },
52 { "" },
53 };
54 int cursyms[] = { X_DUMPDEV, X_DUMPLO, X_VERSION, X_DUMPMAG, -1 };
55 int dumpsyms[] = { X_TIME, X_DUMPSIZE, X_VERSION, X_PANICSTR, X_DUMPMAG, -1 };
56
57 struct nlist dump_nl[] = { /* Name list for dumped system. */
58 { "_dumpdev" }, /* Entries MUST be the same as */
59 { "_dumplo" }, /* those in current_nl[]. */
60 { "_time" },
61 { "_dumpsize" },
62 { "_version" },
63 { "_panicstr" },
64 { "_dumpmag" },
65 { "" },
66 };
67
68 /* Types match kernel declarations. */
69 long dumplo; /* where dump starts on dumpdev */
70 int dumpmag; /* magic number in dump */
71 int dumpsize; /* amount of memory dumped */
72
73 char *vmunix;
74 char *dirname; /* directory to save dumps in */
75 char *ddname; /* name of dump device */
76 dev_t dumpdev; /* dump device */
77 int dumpfd; /* read/write descriptor on block dev */
78 time_t now; /* current date */
79 char panic_mesg[1024];
80 int panicstr;
81 char vers[1024];
82
83 int clear, compress, force, verbose; /* flags */
84
85 void check_kmem __P((void));
86 int check_space __P((void));
87 void clear_dump __P((void));
88 int Create __P((char *, int));
89 int dump_exists __P((void));
90 char *find_dev __P((dev_t, int));
91 int get_crashtime __P((void));
92 void kmem_setup __P((void));
93 void log __P((int, char *, ...));
94 void Lseek __P((int, off_t, int));
95 int Open __P((char *, int rw));
96 int Read __P((int, void *, int));
97 char *rawname __P((char *s));
98 void save_core __P((void));
99 void usage __P((void));
100 void Write __P((int, void *, int));
101
102 int
main(argc,argv)103 main(argc, argv)
104 int argc;
105 char *argv[];
106 {
107 int ch;
108
109 openlog("savecore", LOG_PERROR, LOG_DAEMON);
110
111 while ((ch = getopt(argc, argv, "cdfN:vz")) != EOF)
112 switch(ch) {
113 case 'c':
114 clear = 1;
115 break;
116 case 'd': /* Not documented. */
117 case 'v':
118 verbose = 1;
119 break;
120 case 'f':
121 force = 1;
122 break;
123 case 'N':
124 vmunix = optarg;
125 break;
126 case 'z':
127 compress = 1;
128 break;
129 case '?':
130 default:
131 usage();
132 }
133 argc -= optind;
134 argv += optind;
135
136 if (!clear) {
137 if (argc != 1 && argc != 2)
138 usage();
139 dirname = argv[0];
140 }
141 if (argc == 2)
142 vmunix = argv[1];
143
144 (void)time(&now);
145 kmem_setup();
146
147 if (clear) {
148 clear_dump();
149 exit(0);
150 }
151
152 if (!dump_exists() && !force)
153 exit(1);
154
155 check_kmem();
156
157 if (panicstr)
158 syslog(LOG_ALERT, "reboot after panic: %s", panic_mesg);
159 else
160 syslog(LOG_ALERT, "reboot");
161
162 if ((!get_crashtime() || !check_space()) && !force)
163 exit(1);
164
165 save_core();
166
167 clear_dump();
168 exit(0);
169 }
170
171 void
kmem_setup()172 kmem_setup()
173 {
174 FILE *fp;
175 int kmem, i;
176 char *dump_sys;
177
178 /*
179 * Some names we need for the currently running system, others for
180 * the system that was running when the dump was made. The values
181 * obtained from the current system are used to look for things in
182 * /dev/kmem that cannot be found in the dump_sys namelist, but are
183 * presumed to be the same (since the disk partitions are probably
184 * the same!)
185 */
186 if ((nlist(_PATH_UNIX, current_nl)) == -1)
187 syslog(LOG_ERR, "%s: nlist: %s", _PATH_UNIX, strerror(errno));
188 for (i = 0; cursyms[i] != -1; i++)
189 if (current_nl[cursyms[i]].n_value == 0) {
190 syslog(LOG_ERR, "%s: %s not in namelist",
191 _PATH_UNIX, current_nl[cursyms[i]].n_name);
192 exit(1);
193 }
194
195 dump_sys = vmunix ? vmunix : _PATH_UNIX;
196 if ((nlist(dump_sys, dump_nl)) == -1)
197 syslog(LOG_ERR, "%s: nlist: %s", dump_sys, strerror(errno));
198 for (i = 0; dumpsyms[i] != -1; i++)
199 if (dump_nl[dumpsyms[i]].n_value == 0) {
200 syslog(LOG_ERR, "%s: %s not in namelist",
201 dump_sys, dump_nl[dumpsyms[i]].n_name);
202 exit(1);
203 }
204
205 kmem = Open(_PATH_KMEM, O_RDONLY);
206 Lseek(kmem, (off_t)current_nl[X_DUMPDEV].n_value, L_SET);
207 (void)Read(kmem, &dumpdev, sizeof(dumpdev));
208 if (dumpdev == NODEV) {
209 syslog(LOG_WARNING, "no core dump (no dumpdev)");
210 exit(1);
211 }
212 Lseek(kmem, (off_t)current_nl[X_DUMPLO].n_value, L_SET);
213 (void)Read(kmem, &dumplo, sizeof(dumplo));
214 if (verbose)
215 (void)printf("dumplo = %d (%d * %d)\n",
216 dumplo, dumplo/DEV_BSIZE, DEV_BSIZE);
217 Lseek(kmem, (off_t)current_nl[X_DUMPMAG].n_value, L_SET);
218 (void)Read(kmem, &dumpmag, sizeof(dumpmag));
219 dumplo *= DEV_BSIZE;
220 ddname = find_dev(dumpdev, S_IFBLK);
221 dumpfd = Open(ddname, O_RDWR);
222 fp = fdopen(kmem, "r");
223 if (fp == NULL) {
224 syslog(LOG_ERR, "%s: fdopen: %m", _PATH_KMEM);
225 exit(1);
226 }
227 if (vmunix)
228 return;
229 (void)fseek(fp, (off_t)current_nl[X_VERSION].n_value, L_SET);
230 (void)fgets(vers, sizeof(vers), fp);
231
232 /* Don't fclose(fp), we use dumpfd later. */
233 }
234
235 void
check_kmem()236 check_kmem()
237 {
238 register char *cp;
239 FILE *fp;
240 char core_vers[1024];
241
242 fp = fdopen(dumpfd, "r");
243 if (fp == NULL) {
244 syslog(LOG_ERR, "%s: fdopen: %m", ddname);
245 exit(1);
246 }
247 fseek(fp, (off_t)(dumplo + ok(dump_nl[X_VERSION].n_value)), L_SET);
248 fgets(core_vers, sizeof(core_vers), fp);
249 if (strcmp(vers, core_vers) && vmunix == 0)
250 syslog(LOG_WARNING,
251 "warning: %s version mismatch:\n\t%s\nand\t%s\n",
252 _PATH_UNIX, vers, core_vers);
253 (void)fseek(fp,
254 (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), L_SET);
255 (void)fread(&panicstr, sizeof(panicstr), 1, fp);
256 if (panicstr) {
257 (void)fseek(fp, dumplo + ok(panicstr), L_SET);
258 cp = panic_mesg;
259 do
260 *cp = getc(fp);
261 while (*cp++ && cp < &panic_mesg[sizeof(panic_mesg)]);
262 }
263 /* Don't fclose(fp), we use dumpfd later. */
264 }
265
266 void
clear_dump()267 clear_dump()
268 {
269 long newdumplo;
270
271 newdumplo = 0;
272 Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
273 Write(dumpfd, &newdumplo, sizeof(newdumplo));
274 }
275
276 int
dump_exists()277 dump_exists()
278 {
279 int newdumpmag;
280
281 Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
282 (void)Read(dumpfd, &newdumpmag, sizeof(newdumpmag));
283 if (newdumpmag != dumpmag) {
284 if (verbose)
285 syslog(LOG_WARNING, "magic number mismatch (%x != %x)",
286 newdumpmag, dumpmag);
287 syslog(LOG_WARNING, "no core dump");
288 return (0);
289 }
290 return (1);
291 }
292
293 char buf[1024 * 1024];
294
295 void
save_core()296 save_core()
297 {
298 register FILE *fp;
299 register int bounds, ifd, nr, nw, ofd;
300 char *rawp, path[MAXPATHLEN];
301
302 /*
303 * Get the current number and update the bounds file. Do the update
304 * now, because may fail later and don't want to overwrite anything.
305 */
306 (void)snprintf(path, sizeof(path), "%s/bounds", dirname);
307 if ((fp = fopen(path, "r")) == NULL)
308 goto err1;
309 if (fgets(buf, sizeof(buf), fp) == NULL) {
310 if (ferror(fp))
311 err1: syslog(LOG_WARNING, "%s: %s", path, strerror(errno));
312 bounds = 0;
313 } else
314 bounds = atoi(buf);
315 if (fp != NULL)
316 (void)fclose(fp);
317 if ((fp = fopen(path, "w")) == NULL)
318 syslog(LOG_ERR, "%s: %m", path);
319 else {
320 (void)fprintf(fp, "%d\n", bounds + 1);
321 (void)fclose(fp);
322 }
323 (void)fclose(fp);
324
325 /* Create the core file. */
326 (void)snprintf(path, sizeof(path), "%s/vmcore.%d%s",
327 dirname, bounds, compress ? ".Z" : "");
328 if (compress) {
329 if ((fp = zopen(path, "w", 0)) == NULL) {
330 syslog(LOG_ERR, "%s: %s", path, strerror(errno));
331 exit(1);
332 }
333 } else
334 ofd = Create(path, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
335
336 /* Open the raw device. */
337 rawp = rawname(ddname);
338 if ((ifd = open(rawp, O_RDONLY)) == -1) {
339 syslog(LOG_WARNING, "%s: %m; using block device", rawp);
340 ifd = dumpfd;
341 }
342
343 /* Read the dump size. */
344 Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), L_SET);
345 (void)Read(dumpfd, &dumpsize, sizeof(dumpsize));
346
347 /* Seek to the start of the core. */
348 Lseek(ifd, (off_t)dumplo, L_SET);
349
350 /* Copy the core file. */
351 dumpsize *= NBPG;
352 syslog(LOG_NOTICE, "writing %score to %s",
353 compress ? "compressed " : "", path);
354 for (; dumpsize > 0; dumpsize -= nr) {
355 (void)printf("%6dK\r", dumpsize / 1024);
356 (void)fflush(stdout);
357 nr = read(ifd, buf, MIN(dumpsize, sizeof(buf)));
358 if (nr <= 0) {
359 if (nr == 0)
360 syslog(LOG_WARNING,
361 "WARNING: EOF on dump device");
362 else
363 syslog(LOG_ERR, "%s: %m", rawp);
364 goto err2;
365 }
366 if (compress)
367 nw = fwrite(buf, 1, nr, fp);
368 else
369 nw = write(ofd, buf, nr);
370 if (nw != nr) {
371 syslog(LOG_ERR, "%s: %s",
372 path, strerror(nw == 0 ? EIO : errno));
373 err2: syslog(LOG_WARNING,
374 "WARNING: vmcore may be incomplete");
375 (void)printf("\n");
376 exit(1);
377 }
378 }
379 (void)printf("\n");
380 (void)close(ifd);
381 if (compress)
382 (void)fclose(fp);
383 else
384 (void)close(ofd);
385
386 /* Copy the kernel. */
387 ifd = Open(vmunix ? vmunix : _PATH_UNIX, O_RDONLY);
388 (void)snprintf(path, sizeof(path), "%s/vmunix.%d%s",
389 dirname, bounds, compress ? ".Z" : "");
390 if (compress) {
391 if ((fp = zopen(path, "w", 0)) == NULL) {
392 syslog(LOG_ERR, "%s: %s", path, strerror(errno));
393 exit(1);
394 }
395 } else
396 ofd = Create(path, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
397 syslog(LOG_NOTICE, "writing %skernel to %s",
398 compress ? "compressed " : "", path);
399 while ((nr = read(ifd, buf, sizeof(buf))) > 0) {
400 if (compress)
401 nw = fwrite(buf, 1, nr, fp);
402 else
403 nw = write(ofd, buf, nr);
404 if (nw != nr) {
405 syslog(LOG_ERR, "%s: %s",
406 path, strerror(nw == 0 ? EIO : errno));
407 syslog(LOG_WARNING,
408 "WARNING: vmunix may be incomplete");
409 exit(1);
410 }
411 }
412 if (nr < 0) {
413 syslog(LOG_ERR, "%s: %s",
414 vmunix ? vmunix : _PATH_UNIX, strerror(errno));
415 syslog(LOG_WARNING,
416 "WARNING: vmunix may be incomplete");
417 exit(1);
418 }
419 if (compress)
420 (void)fclose(fp);
421 else
422 (void)close(ofd);
423 }
424
425 char *
find_dev(dev,type)426 find_dev(dev, type)
427 register dev_t dev;
428 register int type;
429 {
430 register DIR *dfd;
431 struct dirent *dir;
432 struct stat sb;
433 char *dp, devname[MAXPATHLEN + 1];
434
435 if ((dfd = opendir(_PATH_DEV)) == NULL) {
436 syslog(LOG_ERR, "%s: %s", _PATH_DEV, strerror(errno));
437 exit(1);
438 }
439 (void)strcpy(devname, _PATH_DEV);
440 while ((dir = readdir(dfd))) {
441 (void)strcpy(devname + sizeof(_PATH_DEV) - 1, dir->d_name);
442 if (lstat(devname, &sb)) {
443 syslog(LOG_ERR, "%s: %s", devname, strerror(errno));
444 continue;
445 }
446 if ((sb.st_mode & S_IFMT) != type)
447 continue;
448 if (dev == sb.st_rdev) {
449 closedir(dfd);
450 if ((dp = strdup(devname)) == NULL) {
451 syslog(LOG_ERR, "%s", strerror(errno));
452 exit(1);
453 }
454 return (dp);
455 }
456 }
457 closedir(dfd);
458 syslog(LOG_ERR, "can't find device %d/%d", major(dev), minor(dev));
459 exit(1);
460 }
461
462 char *
rawname(s)463 rawname(s)
464 char *s;
465 {
466 char *sl, name[MAXPATHLEN];
467
468 if ((sl = strrchr(s, '/')) == NULL || sl[1] == '0') {
469 syslog(LOG_ERR,
470 "can't make raw dump device name from %s", s);
471 return (s);
472 }
473 (void)snprintf(name, sizeof(name), "%.*s/r%s", sl - s, s, sl + 1);
474 if ((sl = strdup(name)) == NULL) {
475 syslog(LOG_ERR, "%s", strerror(errno));
476 exit(1);
477 }
478 return (sl);
479 }
480
481 int
get_crashtime()482 get_crashtime()
483 {
484 time_t dumptime; /* Time the dump was taken. */
485
486 Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), L_SET);
487 (void)Read(dumpfd, &dumptime, sizeof(dumptime));
488 if (dumptime == 0) {
489 if (verbose)
490 syslog(LOG_ERR, "dump time is zero");
491 return (0);
492 }
493 (void)printf("savecore: system went down at %s", ctime(&dumptime));
494 #define LEEWAY (7 * SECSPERDAY)
495 if (dumptime < now - LEEWAY || dumptime > now + LEEWAY) {
496 (void)printf("dump time is unreasonable\n");
497 return (0);
498 }
499 return (1);
500 }
501
502 int
check_space()503 check_space()
504 {
505 register FILE *fp;
506 char *tvmunix;
507 off_t minfree, spacefree, vmunixsize, needed;
508 struct stat st;
509 struct statfs fsbuf;
510 char buf[100], path[MAXPATHLEN];
511
512 tvmunix = vmunix ? vmunix : _PATH_UNIX;
513 if (stat(tvmunix, &st) < 0) {
514 syslog(LOG_ERR, "%s: %m", tvmunix);
515 exit(1);
516 }
517 vmunixsize = st.st_blocks * S_BLKSIZE;
518 if (statfs(dirname, &fsbuf) < 0) {
519 syslog(LOG_ERR, "%s: %m", dirname);
520 exit(1);
521 }
522 spacefree = (fsbuf.f_bavail * fsbuf.f_bsize) / 1024;
523
524 (void)snprintf(path, sizeof(path), "%s/minfree", dirname);
525 if ((fp = fopen(path, "r")) == NULL)
526 minfree = 0;
527 else {
528 if (fgets(buf, sizeof(buf), fp) == NULL)
529 minfree = 0;
530 else
531 minfree = atoi(buf);
532 (void)fclose(fp);
533 }
534
535 needed = (dumpsize + vmunixsize) / 1024;
536 if (minfree > 0 && spacefree - needed < minfree) {
537 syslog(LOG_WARNING,
538 "no dump, not enough free space on device");
539 return (0);
540 }
541 if (spacefree - needed < minfree)
542 syslog(LOG_WARNING,
543 "dump performed, but free space threshold crossed");
544 return (1);
545 }
546
547 int
Open(name,rw)548 Open(name, rw)
549 char *name;
550 int rw;
551 {
552 int fd;
553
554 if ((fd = open(name, rw, 0)) < 0) {
555 syslog(LOG_ERR, "%s: %m", name);
556 exit(1);
557 }
558 return (fd);
559 }
560
561 int
Read(fd,bp,size)562 Read(fd, bp, size)
563 int fd, size;
564 void *bp;
565 {
566 int nr;
567
568 nr = read(fd, bp, size);
569 if (nr != size) {
570 syslog(LOG_ERR, "read: %m");
571 exit(1);
572 }
573 return (nr);
574 }
575
576 void
Lseek(fd,off,flag)577 Lseek(fd, off, flag)
578 int fd, flag;
579 off_t off;
580 {
581 off_t ret;
582
583 ret = lseek(fd, off, flag);
584 if (ret == -1) {
585 syslog(LOG_ERR, "lseek: %m");
586 exit(1);
587 }
588 }
589
590 int
Create(file,mode)591 Create(file, mode)
592 char *file;
593 int mode;
594 {
595 register int fd;
596
597 fd = open(file, O_WRONLY | O_CREAT | O_TRUNC, mode);
598 if (fd < 0) {
599 syslog(LOG_ERR, "%s: %m", file);
600 exit(1);
601 }
602 return (fd);
603 }
604
605 void
Write(fd,bp,size)606 Write(fd, bp, size)
607 int fd, size;
608 void *bp;
609 {
610 int n;
611
612 if ((n = write(fd, bp, size)) < size) {
613 syslog(LOG_ERR, "write: %s", strerror(n == -1 ? errno : EIO));
614 exit(1);
615 }
616 }
617
618 void
usage()619 usage()
620 {
621 (void)syslog(LOG_ERR, "usage: savecore [-cfvz] [-N system] directory");
622 exit(1);
623 }
624