[unix-history] / usr.sbin / kgmon / kgmon.c

/*
 * Copyright (c) 1983 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1983 The Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)kgmon.c	5.12 (Berkeley) 7/1/91";
#endif /* not lint */

#include <sys/param.h>
#if BSD >= 199103
#define NEWVM
#endif
#include <sys/file.h>
#ifndef NEWVM
#include <machine/pte.h>
#include <sys/vm.h>
#endif
#include <sys/gprof.h>
#include <stdio.h>
#include <nlist.h>
#include <ctype.h>
#include <paths.h>

#define	PROFILING_ON	0
#define	PROFILING_OFF	3

u_long	s_textsize;
off_t	sbuf, klseek(), lseek();
int	ssiz;

struct nlist nl[] = {
#define	N_SYSMAP	0
	{ "_Sysmap" },
#define	N_SYSSIZE	1
	{ "_Syssize" },
#define N_FROMS		2
	{ "_froms" },
#define	N_PROFILING	3
	{ "_profiling" },
#define	N_S_LOWPC	4
	{ "_s_lowpc" },
#define	N_S_TEXTSIZE	5
	{ "_s_textsize" },
#define	N_SBUF		6
	{ "_sbuf" },
#define N_SSIZ		7
	{ "_ssiz" },
#define	N_TOS		8
	{ "_tos" },
	0,
};

struct	pte *Sysmap;

int	kmem;
int	bflag, hflag, kflag, rflag, pflag;
int	debug = 0;

main(argc, argv)
	int argc;
	char **argv;
{
	extern char *optarg;
	extern int optind;
	int ch, mode, disp, openmode;
	char *system, *kmemf, *malloc();

	kmemf = _PATH_KMEM;
	system = _PATH_UNIX;
	while ((ch = getopt(argc, argv, "M:N:bhpr")) != EOF)
		switch((char)ch) {
		case 'M':
			kmemf = optarg;
			kflag = 1;
			break;
		case 'N':
			system = optarg;
			break;
		case 'b':
			bflag = 1;
			break;
		case 'h':
			hflag = 1;
			break;
		case 'p':
			pflag = 1;
			break;
		case 'r':
			rflag = 1;
			break;
		default:
			(void)fprintf(stderr,
			    "usage: kgmon [-bhrp] [-M core] [-N system]\n");
			exit(1);
		}
	argc -= optind;
	argv += optind;

#define BACKWARD_COMPATIBILITY
#ifdef	BACKWARD_COMPATIBILITY
	if (*argv) {
		system = *argv;
		if (*++argv) {
			kmemf = *argv;
			++kflag;
		}
	}
#endif

	if (nlist(system, nl) < 0 || nl[0].n_type == 0) {
		(void)fprintf(stderr, "kgmon: %s: no namelist\n", system);
		exit(2);
	}
	if (!nl[N_PROFILING].n_value) {
		(void)fprintf(stderr,
		    "kgmon: profiling: not defined in kernel.\n");
		exit(10);
	}

	openmode = (bflag || hflag || pflag || rflag) ? O_RDWR : O_RDONLY;
	kmem = open(kmemf, openmode);
	if (kmem < 0) {
		openmode = O_RDONLY;
		kmem = open(kmemf, openmode);
		if (kmem < 0) {
			perror(kmemf);
			exit(3);
		}
		(void)fprintf(stderr, "%s opened read-only\n", kmemf);
		if (rflag)
			(void)fprintf(stderr, "-r supressed\n");
		if (bflag)
			(void)fprintf(stderr, "-b supressed\n");
		if (hflag)
			(void)fprintf(stderr, "-h supressed\n");
		rflag = bflag = hflag = 0;
	}
	if (kflag) {
#ifdef NEWVM
		(void)fprintf(stderr,
		    "kgmon: can't do core files yet\n");
		exit(1);
#else
		off_t off;

		Sysmap = (struct pte *)
		   malloc((u_int)(nl[N_SYSSIZE].n_value * sizeof(struct pte)));
		if (!Sysmap) {
			(void)fprintf(stderr,
			    "kgmon: can't get memory for Sysmap.\n");
			exit(1);
		}
		off = nl[N_SYSMAP].n_value & ~KERNBASE;
		(void)lseek(kmem, off, L_SET);
		(void)read(kmem, (char *)Sysmap,
		    (int)(nl[N_SYSSIZE].n_value * sizeof(struct pte)));
#endif
	}
	mode = kfetch(N_PROFILING);
	if (hflag)
		disp = PROFILING_OFF;
	else if (bflag)
		disp = PROFILING_ON;
	else
		disp = mode;
	if (pflag) {
		if (openmode == O_RDONLY && mode == PROFILING_ON)
			(void)fprintf(stderr, "data may be inconsistent\n");
		dumpstate();
	}
	if (rflag)
		resetstate();
	turnonoff(disp);
	(void)fprintf(stdout,
	    "kernel profiling is %s.\n", disp ? "off" : "running");
	exit(0);
}

dumpstate()
{
	extern int errno;
	struct rawarc rawarc;
	struct tostruct *tos;
	u_long frompc;
	off_t kfroms, ktos;
	u_short *froms;		/* froms is a bunch of u_shorts indexing tos */
	int i, fd, fromindex, endfrom, fromssize, tossize, toindex;
	char buf[BUFSIZ], *s_lowpc, *malloc(), *strerror();

	turnonoff(PROFILING_OFF);
	fd = creat("gmon.out", 0666);
	if (fd < 0) {
		perror("gmon.out");
		return;
	}
	ssiz = kfetch(N_SSIZ);
	sbuf = kfetch(N_SBUF);
	(void)klseek(kmem, (off_t)sbuf, L_SET);
	for (i = ssiz; i > 0; i -= BUFSIZ) {
		read(kmem, buf, i < BUFSIZ ? i : BUFSIZ);
		write(fd, buf, i < BUFSIZ ? i : BUFSIZ);
	}
	s_textsize = kfetch(N_S_TEXTSIZE);
	fromssize = s_textsize / HASHFRACTION;
	froms = (u_short *)malloc((u_int)fromssize);
	kfroms = kfetch(N_FROMS);
	(void)klseek(kmem, kfroms, L_SET);
	i = read(kmem, ((char *)(froms)), fromssize);
	if (i != fromssize) {
		(void)fprintf(stderr, "read kmem: request %d, got %d: %s",
		    fromssize, i, strerror(errno));
		exit(5);
	}
	tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct);
	tos = (struct tostruct *)malloc((u_int)tossize);
	ktos = kfetch(N_TOS);
	(void)klseek(kmem, ktos, L_SET);
	i = read(kmem, ((char *)(tos)), tossize);
	if (i != tossize) {
		(void)fprintf(stderr, "read kmem: request %d, got %d: %s",
		    tossize, i, strerror(errno));
		exit(6);
	}
	s_lowpc = (char *)kfetch(N_S_LOWPC);
	if (debug)
		(void)fprintf(stderr, "s_lowpc 0x%x, s_textsize 0x%x\n",
		    s_lowpc, s_textsize);
	endfrom = fromssize / sizeof(*froms);
	for (fromindex = 0; fromindex < endfrom; fromindex++) {
		if (froms[fromindex] == 0)
			continue;
		frompc = (u_long)s_lowpc +
		    (fromindex * HASHFRACTION * sizeof(*froms));
		for (toindex = froms[fromindex]; toindex != 0;
		   toindex = tos[toindex].link) {
			if (debug)
			    (void)fprintf(stderr,
			    "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
			    frompc, tos[toindex].selfpc, tos[toindex].count);
			rawarc.raw_frompc = frompc;
			rawarc.raw_selfpc = (u_long)tos[toindex].selfpc;
			rawarc.raw_count = tos[toindex].count;
			write(fd, (char *)&rawarc, sizeof (rawarc));
		}
	}
	close(fd);
}

resetstate()
{
	off_t kfroms, ktos;
	int i, fromssize, tossize;
	char buf[BUFSIZ];

	turnonoff(PROFILING_OFF);
	bzero(buf, BUFSIZ);
	ssiz = kfetch(N_SSIZ);
	sbuf = kfetch(N_SBUF);
	ssiz -= sizeof(struct phdr);
	sbuf += sizeof(struct phdr);
	(void)klseek(kmem, (off_t)sbuf, L_SET);
	for (i = ssiz; i > 0; i -= BUFSIZ)
		if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
			perror("sbuf write");
			exit(7);
		}
	s_textsize = kfetch(N_S_TEXTSIZE);
	fromssize = s_textsize / HASHFRACTION;
	kfroms = kfetch(N_FROMS);
	(void)klseek(kmem, kfroms, L_SET);
	for (i = fromssize; i > 0; i -= BUFSIZ)
		if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
			perror("kforms write");
			exit(8);
		}
	tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct);
	ktos = kfetch(N_TOS);
	(void)klseek(kmem, ktos, L_SET);
	for (i = tossize; i > 0; i -= BUFSIZ)
		if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
			perror("ktos write");
			exit(9);
		}
}

turnonoff(onoff)
	int onoff;
{
	(void)klseek(kmem, (long)nl[N_PROFILING].n_value, L_SET);
	(void)write(kmem, (char *)&onoff, sizeof (onoff));
}

kfetch(index)
	int index;
{
	off_t off;
	int value;

	if ((off = nl[index].n_value) == 0) {
		printf("%s: not defined in kernel\n", nl[index].n_name);
		exit(11);
	}
	if (klseek(kmem, off, L_SET) == -1) {
		perror("lseek");
		exit(12);
	}
	if (read(kmem, (char *)&value, sizeof (value)) != sizeof (value)) {
		perror("read");
		exit(13);
	}
	return (value);
}

off_t
klseek(fd, base, off)
	int fd, off;
	off_t base;
{

#ifndef NEWVM
	if (kflag) {	/* get kernel pte */
		base &= ~KERNBASE;
		base = ctob(Sysmap[btop(base)].pg_pfnum) + (base & PGOFSET);
	}
#endif
	return (lseek(fd, base, off));
}
Commit	Line	Data
15637ed4 RG	1	/*
	2	* Copyright (c) 1983 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34	#ifndef lint
	35	char copyright[] =
	36	"@(#) Copyright (c) 1983 The Regents of the University of California.\n\
	37	All rights reserved.\n";
	38	#endif /* not lint */
	39
	40	#ifndef lint
	41	static char sccsid[] = "@(#)kgmon.c 5.12 (Berkeley) 7/1/91";
	42	#endif /* not lint */
	43
	44	#include <sys/param.h>
	45	#if BSD >= 199103
	46	#define NEWVM
	47	#endif
	48	#include <sys/file.h>
	49	#ifndef NEWVM
	50	#include <machine/pte.h>
	51	#include <sys/vm.h>
	52	#endif
	53	#include <sys/gprof.h>
	54	#include <stdio.h>
	55	#include <nlist.h>
	56	#include <ctype.h>
	57	#include <paths.h>
	58
	59	#define PROFILING_ON 0
	60	#define PROFILING_OFF 3
	61
	62	u_long s_textsize;
	63	off_t sbuf, klseek(), lseek();
	64	int ssiz;
65
66	struct nlist nl[] = {
67	#define N_SYSMAP 0
68	{ "_Sysmap" },
69	#define N_SYSSIZE 1
70	{ "_Syssize" },
71	#define N_FROMS 2
72	{ "_froms" },
73	#define N_PROFILING 3
74	{ "_profiling" },
75	#define N_S_LOWPC 4
76	{ "_s_lowpc" },
77	#define N_S_TEXTSIZE 5
78	{ "_s_textsize" },
79	#define N_SBUF 6
80	{ "_sbuf" },
81	#define N_SSIZ 7
82	{ "_ssiz" },
83	#define N_TOS 8
84	{ "_tos" },
85	0,
86	};
87
88	struct pte *Sysmap;
89
90	int kmem;
91	int bflag, hflag, kflag, rflag, pflag;
92	int debug = 0;
93
94	main(argc, argv)
95	int argc;
96	char **argv;
97	{
98	extern char *optarg;
99	extern int optind;
100	int ch, mode, disp, openmode;
101	char system, kmemf, *malloc();
102
103	kmemf = _PATH_KMEM;
104	system = _PATH_UNIX;
105	while ((ch = getopt(argc, argv, "M:N:bhpr")) != EOF)
106	switch((char)ch) {
107	case 'M':
108	kmemf = optarg;
109	kflag = 1;
110	break;
111	case 'N':
112	system = optarg;
113	break;
114	case 'b':
115	bflag = 1;
116	break;
117	case 'h':
118	hflag = 1;
119	break;
120	case 'p':
121	pflag = 1;
122	break;
123	case 'r':
124	rflag = 1;
125	break;
126	default:
127	(void)fprintf(stderr,
128	"usage: kgmon [-bhrp] [-M core] [-N system]\n");
129	exit(1);
130	}
131	argc -= optind;
132	argv += optind;
133
134	#define BACKWARD_COMPATIBILITY
135	#ifdef BACKWARD_COMPATIBILITY
136	if (*argv) {
137	system = *argv;
138	if (*++argv) {
139	kmemf = *argv;
140	++kflag;
141	}
142	}
143	#endif
144
145	if (nlist(system, nl) < 0 \|\| nl[0].n_type == 0) {
146	(void)fprintf(stderr, "kgmon: %s: no namelist\n", system);
147	exit(2);
148	}
149	if (!nl[N_PROFILING].n_value) {
150	(void)fprintf(stderr,
151	"kgmon: profiling: not defined in kernel.\n");
152	exit(10);
153	}
154
155	openmode = (bflag \|\| hflag \|\| pflag \|\| rflag) ? O_RDWR : O_RDONLY;
156	kmem = open(kmemf, openmode);
157	if (kmem < 0) {
158	openmode = O_RDONLY;
159	kmem = open(kmemf, openmode);
160	if (kmem < 0) {
161	perror(kmemf);
162	exit(3);
163	}
164	(void)fprintf(stderr, "%s opened read-only\n", kmemf);
165	if (rflag)
166	(void)fprintf(stderr, "-r supressed\n");
167	if (bflag)
168	(void)fprintf(stderr, "-b supressed\n");
169	if (hflag)
170	(void)fprintf(stderr, "-h supressed\n");
171	rflag = bflag = hflag = 0;
172	}
173	if (kflag) {
174	#ifdef NEWVM
175	(void)fprintf(stderr,
176	"kgmon: can't do core files yet\n");
177	exit(1);
178	#else
179	off_t off;
180
181	Sysmap = (struct pte *)
182	malloc((u_int)(nl[N_SYSSIZE].n_value * sizeof(struct pte)));
183	if (!Sysmap) {
184	(void)fprintf(stderr,
185	"kgmon: can't get memory for Sysmap.\n");
186	exit(1);
187	}
188	off = nl[N_SYSMAP].n_value & ~KERNBASE;
189	(void)lseek(kmem, off, L_SET);
190	(void)read(kmem, (char *)Sysmap,
191	(int)(nl[N_SYSSIZE].n_value * sizeof(struct pte)));
192	#endif
193	}
194	mode = kfetch(N_PROFILING);
195	if (hflag)
196	disp = PROFILING_OFF;
197	else if (bflag)
198	disp = PROFILING_ON;
199	else
200	disp = mode;
201	if (pflag) {
202	if (openmode == O_RDONLY && mode == PROFILING_ON)
203	(void)fprintf(stderr, "data may be inconsistent\n");
204	dumpstate();
205	}
206	if (rflag)
207	resetstate();
208	turnonoff(disp);
209	(void)fprintf(stdout,
210	"kernel profiling is %s.\n", disp ? "off" : "running");
211	exit(0);
212	}
213
214	dumpstate()
215	{
216	extern int errno;
217	struct rawarc rawarc;
218	struct tostruct *tos;
219	u_long frompc;
220	off_t kfroms, ktos;
221	u_short froms; / froms is a bunch of u_shorts indexing tos */
222	int i, fd, fromindex, endfrom, fromssize, tossize, toindex;
223	char buf[BUFSIZ], s_lowpc, malloc(), *strerror();
224
225	turnonoff(PROFILING_OFF);
226	fd = creat("gmon.out", 0666);
227	if (fd < 0) {
228	perror("gmon.out");
229	return;
230	}
231	ssiz = kfetch(N_SSIZ);
232	sbuf = kfetch(N_SBUF);
233	(void)klseek(kmem, (off_t)sbuf, L_SET);
234	for (i = ssiz; i > 0; i -= BUFSIZ) {
235	read(kmem, buf, i < BUFSIZ ? i : BUFSIZ);
236	write(fd, buf, i < BUFSIZ ? i : BUFSIZ);
237	}
238	s_textsize = kfetch(N_S_TEXTSIZE);
239	fromssize = s_textsize / HASHFRACTION;
240	froms = (u_short *)malloc((u_int)fromssize);
241	kfroms = kfetch(N_FROMS);
242	(void)klseek(kmem, kfroms, L_SET);
243	i = read(kmem, ((char *)(froms)), fromssize);
244	if (i != fromssize) {
245	(void)fprintf(stderr, "read kmem: request %d, got %d: %s",
246	fromssize, i, strerror(errno));
247	exit(5);
248	}
249	tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct);
250	tos = (struct tostruct *)malloc((u_int)tossize);
251	ktos = kfetch(N_TOS);
252	(void)klseek(kmem, ktos, L_SET);
253	i = read(kmem, ((char *)(tos)), tossize);
254	if (i != tossize) {
255	(void)fprintf(stderr, "read kmem: request %d, got %d: %s",
256	tossize, i, strerror(errno));
257	exit(6);
258	}
259	s_lowpc = (char *)kfetch(N_S_LOWPC);
260	if (debug)
261	(void)fprintf(stderr, "s_lowpc 0x%x, s_textsize 0x%x\n",
262	s_lowpc, s_textsize);
263	endfrom = fromssize / sizeof(*froms);
264	for (fromindex = 0; fromindex < endfrom; fromindex++) {
265	if (froms[fromindex] == 0)
266	continue;
267	frompc = (u_long)s_lowpc +
268	(fromindex * HASHFRACTION * sizeof(*froms));
269	for (toindex = froms[fromindex]; toindex != 0;
270	toindex = tos[toindex].link) {
271	if (debug)
272	(void)fprintf(stderr,
273	"[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" ,
274	frompc, tos[toindex].selfpc, tos[toindex].count);
275	rawarc.raw_frompc = frompc;
276	rawarc.raw_selfpc = (u_long)tos[toindex].selfpc;
277	rawarc.raw_count = tos[toindex].count;
278	write(fd, (char *)&rawarc, sizeof (rawarc));
279	}
280	}
281	close(fd);
282	}
283
284	resetstate()
285	{
286	off_t kfroms, ktos;
287	int i, fromssize, tossize;
288	char buf[BUFSIZ];
289
290	turnonoff(PROFILING_OFF);
291	bzero(buf, BUFSIZ);
292	ssiz = kfetch(N_SSIZ);
293	sbuf = kfetch(N_SBUF);
294	ssiz -= sizeof(struct phdr);
295	sbuf += sizeof(struct phdr);
296	(void)klseek(kmem, (off_t)sbuf, L_SET);
297	for (i = ssiz; i > 0; i -= BUFSIZ)
298	if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
299	perror("sbuf write");
300	exit(7);
301	}
302	s_textsize = kfetch(N_S_TEXTSIZE);
303	fromssize = s_textsize / HASHFRACTION;
304	kfroms = kfetch(N_FROMS);
305	(void)klseek(kmem, kfroms, L_SET);
306	for (i = fromssize; i > 0; i -= BUFSIZ)
307	if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
308	perror("kforms write");
309	exit(8);
310	}
311	tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct);
312	ktos = kfetch(N_TOS);
313	(void)klseek(kmem, ktos, L_SET);
314	for (i = tossize; i > 0; i -= BUFSIZ)
315	if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) {
316	perror("ktos write");
317	exit(9);
318	}
319	}
320
321	turnonoff(onoff)
322	int onoff;
323	{
324	(void)klseek(kmem, (long)nl[N_PROFILING].n_value, L_SET);
325	(void)write(kmem, (char *)&onoff, sizeof (onoff));
326	}
327
328	kfetch(index)
329	int index;
330	{
331	off_t off;
332	int value;
333
334	if ((off = nl[index].n_value) == 0) {
335	printf("%s: not defined in kernel\n", nl[index].n_name);
336	exit(11);
337	}
338	if (klseek(kmem, off, L_SET) == -1) {
339	perror("lseek");
340	exit(12);
341	}
342	if (read(kmem, (char *)&value, sizeof (value)) != sizeof (value)) {
343	perror("read");
344	exit(13);
345	}
346	return (value);
347	}
348
349	off_t
350	klseek(fd, base, off)
351	int fd, off;
352	off_t base;
353	{
354
355	#ifndef NEWVM
356	if (kflag) { /* get kernel pte */
357	base &= ~KERNBASE;
358	base = ctob(Sysmap[btop(base)].pg_pfnum) + (base & PGOFSET);
359	}
360	#endif
361	return (lseek(fd, base, off));
362	}