1 /* 2 * Copyright (c) 1983 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * %sccs.include.redist.c% 6 */ 7 8 #ifndef lint 9 char copyright[] = 10 "@(#) Copyright (c) 1983 The Regents of the University of California.\n\ 11 All rights reserved.\n"; 12 #endif /* not lint */ 13 14 #ifndef lint 15 static char sccsid[] = "@(#)kgmon.c 5.11 (Berkeley) 06/06/91"; 16 #endif /* not lint */ 17 18 #include <machine/pte.h> 19 20 #include <sys/param.h> 21 #include <sys/file.h> 22 #include <sys/vm.h> 23 #include <sys/gprof.h> 24 #include <stdio.h> 25 #include <nlist.h> 26 #include <ctype.h> 27 #include <paths.h> 28 29 #define PROFILING_ON 0 30 #define PROFILING_OFF 3 31 32 u_long s_textsize; 33 off_t sbuf, klseek(), lseek(); 34 int ssiz; 35 36 struct nlist nl[] = { 37 #define N_SYSMAP 0 38 { "_Sysmap" }, 39 #define N_SYSSIZE 1 40 { "_Syssize" }, 41 #define N_FROMS 2 42 { "_froms" }, 43 #define N_PROFILING 3 44 { "_profiling" }, 45 #define N_S_LOWPC 4 46 { "_s_lowpc" }, 47 #define N_S_TEXTSIZE 5 48 { "_s_textsize" }, 49 #define N_SBUF 6 50 { "_sbuf" }, 51 #define N_SSIZ 7 52 { "_ssiz" }, 53 #define N_TOS 8 54 { "_tos" }, 55 0, 56 }; 57 58 struct pte *Sysmap; 59 60 int kmem; 61 int bflag, hflag, kflag, rflag, pflag; 62 int debug = 0; 63 64 main(argc, argv) 65 int argc; 66 char **argv; 67 { 68 extern char *optarg; 69 extern int optind; 70 int ch, mode, disp, openmode; 71 char *system, *kmemf, *malloc(); 72 73 kmemf = _PATH_KMEM; 74 system = _PATH_UNIX; 75 while ((ch = getopt(argc, argv, "M:N:bhpr")) != EOF) 76 switch((char)ch) { 77 case 'M': 78 kmemf = optarg; 79 kflag = 1; 80 break; 81 case 'N': 82 system = optarg; 83 break; 84 case 'b': 85 bflag = 1; 86 break; 87 case 'h': 88 hflag = 1; 89 break; 90 case 'p': 91 pflag = 1; 92 break; 93 case 'r': 94 rflag = 1; 95 break; 96 default: 97 (void)fprintf(stderr, 98 "usage: kgmon [-bhrp] [-M core] [-N system]\n"); 99 exit(1); 100 } 101 argc -= optind; 102 argv += optind; 103 104 #define BACKWARD_COMPATIBILITY 105 #ifdef BACKWARD_COMPATIBILITY 106 if (*argv) { 107 system = *argv; 108 if (*++argv) { 109 kmemf = *argv; 110 ++kflag; 111 } 112 } 113 #endif 114 115 if (nlist(system, nl) < 0 || nl[0].n_type == 0) { 116 (void)fprintf(stderr, "kgmon: %s: no namelist\n", system); 117 exit(2); 118 } 119 if (!nl[N_PROFILING].n_value) { 120 (void)fprintf(stderr, 121 "kgmon: profiling: not defined in kernel.\n"); 122 exit(10); 123 } 124 125 openmode = (bflag || hflag || pflag || rflag) ? O_RDWR : O_RDONLY; 126 kmem = open(kmemf, openmode); 127 if (kmem < 0) { 128 openmode = O_RDONLY; 129 kmem = open(kmemf, openmode); 130 if (kmem < 0) { 131 perror(kmemf); 132 exit(3); 133 } 134 (void)fprintf(stderr, "%s opened read-only\n", kmemf); 135 if (rflag) 136 (void)fprintf(stderr, "-r supressed\n"); 137 if (bflag) 138 (void)fprintf(stderr, "-b supressed\n"); 139 if (hflag) 140 (void)fprintf(stderr, "-h supressed\n"); 141 rflag = bflag = hflag = 0; 142 } 143 if (kflag) { 144 off_t off; 145 146 Sysmap = (struct pte *) 147 malloc((u_int)(nl[N_SYSSIZE].n_value * sizeof(struct pte))); 148 if (!Sysmap) { 149 (void)fprintf(stderr, 150 "kgmon: can't get memory for Sysmap.\n"); 151 exit(1); 152 } 153 off = nl[N_SYSMAP].n_value & ~KERNBASE; 154 (void)lseek(kmem, off, L_SET); 155 (void)read(kmem, (char *)Sysmap, 156 (int)(nl[N_SYSSIZE].n_value * sizeof(struct pte))); 157 } 158 mode = kfetch(N_PROFILING); 159 if (hflag) 160 disp = PROFILING_OFF; 161 else if (bflag) 162 disp = PROFILING_ON; 163 else 164 disp = mode; 165 if (pflag) { 166 if (openmode == O_RDONLY && mode == PROFILING_ON) 167 (void)fprintf(stderr, "data may be inconsistent\n"); 168 dumpstate(); 169 } 170 if (rflag) 171 resetstate(); 172 turnonoff(disp); 173 (void)fprintf(stdout, 174 "kernel profiling is %s.\n", disp ? "off" : "running"); 175 exit(0); 176 } 177 178 dumpstate() 179 { 180 extern int errno; 181 struct rawarc rawarc; 182 struct tostruct *tos; 183 u_long frompc; 184 off_t kfroms, ktos; 185 u_short *froms; /* froms is a bunch of u_shorts indexing tos */ 186 int i, fd, fromindex, endfrom, fromssize, tossize, toindex; 187 char buf[BUFSIZ], *s_lowpc, *malloc(), *strerror(); 188 189 turnonoff(PROFILING_OFF); 190 fd = creat("gmon.out", 0666); 191 if (fd < 0) { 192 perror("gmon.out"); 193 return; 194 } 195 ssiz = kfetch(N_SSIZ); 196 sbuf = kfetch(N_SBUF); 197 (void)klseek(kmem, (off_t)sbuf, L_SET); 198 for (i = ssiz; i > 0; i -= BUFSIZ) { 199 read(kmem, buf, i < BUFSIZ ? i : BUFSIZ); 200 write(fd, buf, i < BUFSIZ ? i : BUFSIZ); 201 } 202 s_textsize = kfetch(N_S_TEXTSIZE); 203 fromssize = s_textsize / HASHFRACTION; 204 froms = (u_short *)malloc((u_int)fromssize); 205 kfroms = kfetch(N_FROMS); 206 (void)klseek(kmem, kfroms, L_SET); 207 i = read(kmem, ((char *)(froms)), fromssize); 208 if (i != fromssize) { 209 (void)fprintf(stderr, "read kmem: request %d, got %d: %s", 210 fromssize, i, strerror(errno)); 211 exit(5); 212 } 213 tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct); 214 tos = (struct tostruct *)malloc((u_int)tossize); 215 ktos = kfetch(N_TOS); 216 (void)klseek(kmem, ktos, L_SET); 217 i = read(kmem, ((char *)(tos)), tossize); 218 if (i != tossize) { 219 (void)fprintf(stderr, "read kmem: request %d, got %d: %s", 220 tossize, i, strerror(errno)); 221 exit(6); 222 } 223 s_lowpc = (char *)kfetch(N_S_LOWPC); 224 if (debug) 225 (void)fprintf(stderr, "s_lowpc 0x%x, s_textsize 0x%x\n", 226 s_lowpc, s_textsize); 227 endfrom = fromssize / sizeof(*froms); 228 for (fromindex = 0; fromindex < endfrom; fromindex++) { 229 if (froms[fromindex] == 0) 230 continue; 231 frompc = (u_long)s_lowpc + 232 (fromindex * HASHFRACTION * sizeof(*froms)); 233 for (toindex = froms[fromindex]; toindex != 0; 234 toindex = tos[toindex].link) { 235 if (debug) 236 (void)fprintf(stderr, 237 "[mcleanup] frompc 0x%x selfpc 0x%x count %d\n" , 238 frompc, tos[toindex].selfpc, tos[toindex].count); 239 rawarc.raw_frompc = frompc; 240 rawarc.raw_selfpc = (u_long)tos[toindex].selfpc; 241 rawarc.raw_count = tos[toindex].count; 242 write(fd, (char *)&rawarc, sizeof (rawarc)); 243 } 244 } 245 close(fd); 246 } 247 248 resetstate() 249 { 250 off_t kfroms, ktos; 251 int i, fromssize, tossize; 252 char buf[BUFSIZ]; 253 254 turnonoff(PROFILING_OFF); 255 bzero(buf, BUFSIZ); 256 ssiz = kfetch(N_SSIZ); 257 sbuf = kfetch(N_SBUF); 258 ssiz -= sizeof(struct phdr); 259 sbuf += sizeof(struct phdr); 260 (void)klseek(kmem, (off_t)sbuf, L_SET); 261 for (i = ssiz; i > 0; i -= BUFSIZ) 262 if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) { 263 perror("sbuf write"); 264 exit(7); 265 } 266 s_textsize = kfetch(N_S_TEXTSIZE); 267 fromssize = s_textsize / HASHFRACTION; 268 kfroms = kfetch(N_FROMS); 269 (void)klseek(kmem, kfroms, L_SET); 270 for (i = fromssize; i > 0; i -= BUFSIZ) 271 if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) { 272 perror("kforms write"); 273 exit(8); 274 } 275 tossize = (s_textsize * ARCDENSITY / 100) * sizeof(struct tostruct); 276 ktos = kfetch(N_TOS); 277 (void)klseek(kmem, ktos, L_SET); 278 for (i = tossize; i > 0; i -= BUFSIZ) 279 if (write(kmem, buf, i < BUFSIZ ? i : BUFSIZ) < 0) { 280 perror("ktos write"); 281 exit(9); 282 } 283 } 284 285 turnonoff(onoff) 286 int onoff; 287 { 288 (void)klseek(kmem, (long)nl[N_PROFILING].n_value, L_SET); 289 (void)write(kmem, (char *)&onoff, sizeof (onoff)); 290 } 291 292 kfetch(index) 293 int index; 294 { 295 off_t off; 296 int value; 297 298 if ((off = nl[index].n_value) == 0) { 299 printf("%s: not defined in kernel\n", nl[index].n_name); 300 exit(11); 301 } 302 if (klseek(kmem, off, L_SET) == -1) { 303 perror("lseek"); 304 exit(12); 305 } 306 if (read(kmem, (char *)&value, sizeof (value)) != sizeof (value)) { 307 perror("read"); 308 exit(13); 309 } 310 return (value); 311 } 312 313 off_t 314 klseek(fd, base, off) 315 int fd, off; 316 off_t base; 317 { 318 if (kflag) { /* get kernel pte */ 319 base &= ~KERNBASE; 320 base = ctob(Sysmap[btop(base)].pg_pfnum) + (base & PGOFSET); 321 } 322 return (lseek(fd, base, off)); 323 } 324