![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kvm_mkdb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / kvm_mkdb|
Return to kvm_mkdb.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / kvm_mkdb |
1.1 root 1: /*-
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1990 The Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)kvm_mkdb.c 5.5 (Berkeley) 6/25/90";
28: #endif /* not lint */
29:
30: #include <sys/param.h>
31: #include <sys/file.h>
32: #include <ndbm.h>
33: #include <a.out.h>
34: #include <kvm.h>
35: #include <paths.h>
36: #include <limits.h>
37: #include <errno.h>
38: #include <string.h>
39: #include <stdio.h>
40:
41: char *tmp;
42: #define basename(cp) ((tmp=rindex((cp), '/')) ? tmp+1 : (cp))
43: #define USAGE "kvm_mkdb"
44:
45: char *progname;
46:
47: main(argc, argv)
48: char *argv[];
49: {
50: DBM *db;
51: char *nlistpath, *nlistname;
52: char dbtemp[MAXPATHLEN];
53: char dbname[MAXPATHLEN];
54: extern char *optarg;
55: extern int optind;
56: int ch;
57:
58: progname = argv[0];
59: while ((ch = getopt(argc, argv, "")) != EOF)
60: switch((char)ch) {
61: case '?':
62: default:
63: fprintf(stderr, "usage: %s", progname, USAGE);
64: exit(1);
65: }
66: argc -= optind;
67: argv += optind;
68:
69: nlistpath = argc > 1 ? argv[0] : _PATH_UNIX;
70: nlistname = basename(nlistpath);
71: sprintf(dbtemp, "%s/kvm_tmp%s", KVMDBDIR, nlistname);
72: sprintf(dbname, "%s/kvm_%s", KVMDBDIR, nlistname);
73: rmdb(dbtemp);
74: umask(0);
75: if ((db = dbm_open(dbtemp, O_CREAT|O_WRONLY|O_EXCL, 0644)) == NULL)
76: syserrexit("error opening dbmfile");
77: if (create_knlist(nlistpath, db) == -1)
78: errexit("error creating kernel namelist");
79: if (create_devnames(db) == -1)
80: errexit("error creating devnames");
81: rmdb(dbname);
82: mvdb(dbtemp, dbname);
83:
84: exit(0);
85: }
86:
87: rmdb(file)
88: char *file;
89: {
90: int len = strlen(file);
91:
92: if (len > (MAXPATHLEN - 5))
93: errexit("pathname too long: %s", file);
94: strcpy(file+len, ".dir");
95: if (unlink(file) < 0 && errno != ENOENT)
96: syserrexit("can't unlink %s", file);
97: strcpy(file+len, ".pag");
98: if (unlink(file) < 0 && errno != ENOENT)
99: syserrexit("can't unlink %s", file);
100: *(file+len) = '\0';
101: }
102:
103: mvdb(from, to)
104: char *from;
105: char *to;
106: {
107: int flen = strlen(from);
108: int tlen = strlen(to);
109:
110: if (flen > (MAXPATHLEN - 5) || tlen > (MAXPATHLEN - 5))
111: errexit("pathname too long: %s or %s", from, to);
112: strcpy(from+flen, ".dir");
113: strcpy(to+tlen, ".dir");
114: if (rename(from, to) == -1)
115: syserrexit("rename %s to %s", from, to);
116: strcpy(from+flen, ".pag");
117: strcpy(to+tlen, ".pag");
118: if (rename(from, to) == -1)
119: syserrexit("rename %s to %s", from, to);
120: *(from+flen) = *(to+tlen) = '\0';
121: }
122:
123: /* from libc/nlist.c */
124: #include <unistd.h>
125:
126: typedef struct nlist NLIST;
127: #define _strx n_un.n_strx
128: #define _name n_un.n_name
129: #define ISVALID(p) (p->_name && p->_name[0])
130: #define MAXSYMSIZE 256
131:
132: create_knlist(name, db)
133: char *name;
134: DBM *db;
135: {
136: register NLIST *p, *s;
137: struct exec ebuf;
138: FILE *fstr, *fsym;
139: NLIST nbuf;
140: off_t strings_offset, symbol_offset, symbol_size, lseek();
141: char sbuf[MAXSYMSIZE+1];
142: register char *bp;
143: register int c, len;
144: datum key, data;
145:
146: if (!(fsym = fopen(name, "r")))
147: syserrexit("can't open %s", name);
148: if (fread((char *)&ebuf, sizeof(struct exec), 1, fsym) != 1 ||
149: N_BADMAG(ebuf))
150: syserrexit("can't read exec");
151:
152: symbol_offset = N_SYMOFF(ebuf);
153: symbol_size = ebuf.a_syms;
154: strings_offset = symbol_offset + symbol_size;
155:
156: if (fseek(fsym, symbol_offset, SEEK_SET) == -1)
157: syserrexit("can't seek symbol table: %x", symbol_offset);
158: if ((fstr = fopen(name, "r")) == NULL)
159: syserrexit("can't open %s", name);
160:
161: sbuf[0] = KVMDB_NLIST;
162: key.dptr = sbuf;
163: data.dptr = (char *)&nbuf;
164: data.dsize = sizeof (NLIST);
165:
166: for (s = &nbuf; symbol_size; symbol_size -= sizeof (NLIST)) {
167: if (fread((char *)s, sizeof (NLIST), 1, fsym) != 1)
168: syserrexit("can't read nlist entry");
169: if (!s->_strx || s->n_type&N_STAB)
170: continue;
171: if (fseek(fstr, strings_offset + s->_strx, SEEK_SET) == -1)
172: syserrexit("can't seek string: %x",
173: strings_offset + s->_strx);
174: /*
175: * read string
176: */
177: bp = sbuf + 1;
178: len = 0;
179: while ((c = fgetc(fstr)) != EOF && c != '\0') {
180: if (++len == MAXSYMSIZE)
181: errexit("string too long");
182: *bp++ = c;
183: }
184: *bp = '\0';
185: /*
186: * and store it
187: */
188: key.dsize = bp - sbuf;
189: if (dbm_store(db, key, data, DBM_INSERT) < 0)
190: syserrexit("dbm_store");
191: if (strcmp(sbuf+1, "_version") == 0) {
192: /*
193: * store the value of version in VERSION
194: */
195: datum vers;
196: char versbuf[_BSD_LINE_MAX];
197: long versoff;
198: long reloffset;
199:
200: /* offset relative to start of text image in VM. */
201: #ifdef hp300
202: reloffset = s->n_value;
203: #endif
204: #ifdef tahoe
205: /*
206: * on tahoe, first 0x800 is reserved for communication
207: * with the console processor.
208: */
209: reloffset = ((s->n_value & ~KERNBASE) - 0x800);
210: #endif
211: #ifdef vax
212: reloffset = (s->n_value & ~KERNBASE);
213: #endif
214: /*
215: * When loaded, data is rounded
216: * to next page cluster after text, but not in file.
217: */
218: reloffset -= CLBYTES - (ebuf.a_text % CLBYTES);
219: versoff = N_TXTOFF(ebuf) + reloffset;
220: if (fseek(fstr, versoff, SEEK_SET) == -1)
221: syserrexit("seek (version): %x", s->n_value);
222: /*
223: * Just read version string up to, and
224: * including newline.
225: */
226: if (fgets(versbuf, _BSD_LINE_MAX, fstr) == NULL)
227: syserrexit("can't read version");
228: strcpy(sbuf+1, "VERSION");
229: key.dsize = (sizeof ("VERSION") - 1) + 1;
230: vers.dptr = versbuf;
231: vers.dsize = strlen(versbuf);
232: if (dbm_store(db, key, vers, DBM_INSERT) < 0)
233: syserrexit("dbm_store: can't store VERSION");
234: }
235: }
236: (void)fclose(fstr);
237: (void)fclose(fsym);
238: return (0);
239: }
240:
241: create_devnames() {}
242:
243: #include <varargs.h>
244:
245: warning(va_alist)
246: va_dcl
247: {
248: char *fmt;
249: va_list ap;
250:
251: fprintf(stderr, "%s: warning: ", progname);
252: va_start(ap);
253: fmt = va_arg(ap, char *);
254: (void) vfprintf(stderr, fmt, ap);
255: va_end(ap);
256: fprintf(stderr, "\n");
257: }
258:
259:
260: errexit(va_alist)
261: va_dcl
262: {
263: char *fmt;
264: va_list ap;
265:
266: fprintf(stderr, "%s: ", progname);
267: va_start(ap);
268: fmt = va_arg(ap, char *);
269: (void) vfprintf(stderr, fmt, ap);
270: va_end(ap);
271: fprintf(stderr, "\n");
272: exit(1);
273: }
274:
275:
276: syserrexit(va_alist)
277: va_dcl
278: {
279: char *fmt;
280: va_list ap;
281:
282: fprintf(stderr, "%s: ", progname);
283: va_start(ap);
284: fmt = va_arg(ap, char *);
285: (void) vfprintf(stderr, fmt, ap);
286: va_end(ap);
287: fprintf(stderr, ": %s\n", strerror(errno));
288: exit(1);
289: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.