clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name kgmon.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.sbin/kgmon/obj -resource-dir /usr/local/lib/clang/13.0.0 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.sbin/kgmon/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/usr.sbin/kgmon/kgmon.c
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | |
15 | |
16 | |
17 | |
18 | |
19 | |
20 | |
21 | |
22 | |
23 | |
24 | |
25 | |
26 | |
27 | |
28 | |
29 | |
30 | |
31 | |
32 | #include <sys/types.h> |
33 | #include <sys/sysctl.h> |
34 | #include <sys/time.h> |
35 | #include <sys/gmon.h> |
36 | |
37 | #include <errno.h> |
38 | #include <err.h> |
39 | #include <fcntl.h> |
40 | #include <kvm.h> |
41 | #include <limits.h> |
42 | #include <stdio.h> |
43 | #include <stdlib.h> |
44 | #include <unistd.h> |
45 | #include <string.h> |
46 | #include <nlist.h> |
47 | #include <paths.h> |
48 | |
49 | struct nlist nl[] = { |
50 | #define N_GMONPARAM 0 |
51 | { "__gmonparam" }, |
52 | #define N_PROFHZ 1 |
53 | { "_profhz" }, |
54 | { NULL } |
55 | }; |
56 | |
57 | struct kvmvars { |
58 | kvm_t *kd; |
59 | struct gmonparam gpm; |
60 | }; |
61 | |
62 | extern char *__progname; |
63 | |
64 | int bflag, cflag, hflag, kflag, rflag, pflag; |
65 | int debug = 0; |
66 | void kgmon(char *, char *, struct kvmvars *, int); |
67 | void setprof(struct kvmvars *, int, int); |
68 | void dumpstate(struct kvmvars *, int); |
69 | void reset(struct kvmvars *, int); |
70 | void kern_readonly(int); |
71 | int getprof(struct kvmvars *, int); |
72 | int getprofhz(struct kvmvars *); |
73 | int openfiles(char *, char *, struct kvmvars *, int); |
74 | int getncpu(void); |
75 | |
76 | int |
77 | main(int argc, char **argv) |
78 | { |
79 | int ch, ncpu, cpuid = -1; |
80 | struct kvmvars kvmvars; |
81 | char *sys, *kmemf; |
82 | const char *p; |
83 | |
84 | kmemf = NULL; |
85 | sys = NULL; |
86 | while ((ch = getopt(argc, argv, "M:N:bc:hpr")) != -1) { |
| 1 | Assuming the condition is false | |
|
| 2 | | Loop condition is false. Execution continues on line 127 | |
|
87 | switch(ch) { |
88 | |
89 | case 'M': |
90 | kmemf = optarg; |
91 | kflag = 1; |
92 | break; |
93 | |
94 | case 'N': |
95 | sys = optarg; |
96 | break; |
97 | |
98 | case 'b': |
99 | bflag = 1; |
100 | break; |
101 | |
102 | case 'c': |
103 | cflag = 1; |
104 | cpuid = strtonum(optarg, 0, 1024, &p); |
105 | if (p) |
106 | errx(1, "illegal CPU id %s: %s", optarg, p); |
107 | break; |
108 | |
109 | case 'h': |
110 | hflag = 1; |
111 | break; |
112 | |
113 | case 'p': |
114 | pflag = 1; |
115 | break; |
116 | |
117 | case 'r': |
118 | rflag = 1; |
119 | break; |
120 | |
121 | default: |
122 | fprintf(stderr, "usage: %s [-bhpr] " |
123 | "[-c cpuid] [-M core] [-N system]\n", __progname); |
124 | exit(1); |
125 | } |
126 | } |
127 | argc -= optind; |
128 | argv += optind; |
129 | |
130 | #define BACKWARD_COMPATIBILITY |
131 | #ifdef BACKWARD_COMPATIBILITY |
132 | if (*argv) { |
| 3 | | Assuming the condition is false | |
|
| |
133 | sys = *argv; |
134 | if (*++argv) { |
135 | kmemf = *argv; |
136 | ++kflag; |
137 | } |
138 | } |
139 | #endif |
140 | |
141 | if (cflag) { |
| 5 | | Assuming 'cflag' is not equal to 0 | |
|
| |
142 | kgmon(sys, kmemf, &kvmvars, cpuid); |
| |
143 | } else { |
144 | ncpu = getncpu(); |
145 | for (cpuid = 0; cpuid < ncpu; cpuid++) |
146 | kgmon(sys, kmemf, &kvmvars, cpuid); |
147 | } |
148 | |
149 | return (0); |
150 | } |
151 | |
152 | void |
153 | kgmon(char *sys, char *kmemf, struct kvmvars *kvp, int cpuid) |
154 | { |
155 | int mode, disp, accessmode; |
156 | |
157 | accessmode = openfiles(sys, kmemf, kvp, cpuid); |
158 | mode = getprof(kvp, cpuid); |
159 | if (hflag) |
| 8 | | Assuming 'hflag' is not equal to 0 | |
|
| |
160 | disp = GMON_PROF_OFF; |
161 | else if (bflag) |
162 | disp = GMON_PROF_ON; |
163 | else |
164 | disp = mode; |
165 | if (pflag) |
| |
| |
166 | dumpstate(kvp, cpuid); |
167 | if (rflag) |
| 12 | | Assuming 'rflag' is not equal to 0 | |
|
| |
168 | reset(kvp, cpuid); |
| |
169 | if (accessmode == O_RDWR) |
170 | setprof(kvp, cpuid, disp); |
171 | printf("%s: kernel profiling is %s for cpu %d.\n", __progname, |
172 | disp == GMON_PROF_OFF ? "off" : "running", cpuid); |
173 | } |
174 | |
175 | |
176 | |
177 | |
178 | int |
179 | openfiles(char *sys, char *kmemf, struct kvmvars *kvp, int cpuid) |
180 | { |
181 | int mib[4], state, openmode; |
182 | size_t size; |
183 | char errbuf[_POSIX2_LINE_MAX]; |
184 | |
185 | if (!kflag) { |
186 | mib[0] = CTL_KERN; |
187 | mib[1] = KERN_PROF; |
188 | mib[2] = GPROF_STATE; |
189 | mib[3] = cpuid; |
190 | size = sizeof state; |
191 | if (sysctl(mib, 4, &state, &size, NULL, 0) == -1) |
192 | errx(20, "profiling not defined in kernel."); |
193 | if (!(bflag || hflag || rflag || |
194 | (pflag && state == GMON_PROF_ON))) |
195 | return (O_RDONLY); |
196 | if (sysctl(mib, 4, NULL, NULL, &state, size) >= 0) |
197 | return (O_RDWR); |
198 | kern_readonly(state); |
199 | return (O_RDONLY); |
200 | } |
201 | openmode = (bflag || hflag || pflag || rflag) ? O_RDWR : O_RDONLY; |
202 | kvp->kd = kvm_openfiles(sys, kmemf, NULL, openmode, errbuf); |
203 | if (kvp->kd == NULL) { |
204 | if (openmode == O_RDWR) { |
205 | openmode = O_RDONLY; |
206 | kvp->kd = kvm_openfiles(sys, kmemf, NULL, O_RDONLY, |
207 | errbuf); |
208 | } |
209 | if (kvp->kd == NULL) |
210 | errx(2, "kvm_openfiles: %s", errbuf); |
211 | kern_readonly(GMON_PROF_ON); |
212 | } |
213 | if (kvm_nlist(kvp->kd, nl) == -1) |
214 | errx(3, "%s: no namelist", sys ? sys : _PATH_UNIX); |
215 | if (!nl[N_GMONPARAM].n_value) |
216 | errx(20, "profiling not defined in kernel."); |
217 | return (openmode); |
218 | } |
219 | |
220 | |
221 | |
222 | |
223 | void |
224 | kern_readonly(int mode) |
225 | { |
226 | extern char *__progname; |
227 | |
228 | (void)fprintf(stderr, "%s: kernel read-only: ", __progname); |
229 | if (pflag && mode == GMON_PROF_ON) |
230 | (void)fprintf(stderr, "data may be inconsistent\n"); |
231 | if (rflag) |
232 | (void)fprintf(stderr, "-r suppressed\n"); |
233 | if (bflag) |
234 | (void)fprintf(stderr, "-b suppressed\n"); |
235 | if (hflag) |
236 | (void)fprintf(stderr, "-h suppressed\n"); |
237 | rflag = bflag = hflag = 0; |
238 | } |
239 | |
240 | |
241 | |
242 | |
243 | int |
244 | getprof(struct kvmvars *kvp, int cpuid) |
245 | { |
246 | int mib[4]; |
247 | size_t size; |
248 | |
249 | if (kflag) { |
250 | size = kvm_read(kvp->kd, nl[N_GMONPARAM].n_value, &kvp->gpm, |
251 | sizeof kvp->gpm); |
252 | } else { |
253 | mib[0] = CTL_KERN; |
254 | mib[1] = KERN_PROF; |
255 | mib[2] = GPROF_GMONPARAM; |
256 | mib[3] = cpuid; |
257 | size = sizeof kvp->gpm; |
258 | if (sysctl(mib, 4, &kvp->gpm, &size, NULL, 0) == -1) |
259 | size = 0; |
260 | } |
261 | if (size != sizeof kvp->gpm) |
262 | errx(4, "cannot get gmonparam: %s", |
263 | kflag ? kvm_geterr(kvp->kd) : strerror(errno)); |
264 | return (kvp->gpm.state); |
265 | } |
266 | |
267 | |
268 | |
269 | |
270 | void |
271 | setprof(struct kvmvars *kvp, int cpuid, int state) |
272 | { |
273 | struct gmonparam *p = (struct gmonparam *)nl[N_GMONPARAM].n_value; |
274 | int mib[4], oldstate; |
275 | size_t sz; |
276 | |
277 | sz = sizeof(state); |
278 | if (!kflag) { |
279 | mib[0] = CTL_KERN; |
280 | mib[1] = KERN_PROF; |
281 | mib[2] = GPROF_STATE; |
282 | mib[3] = cpuid; |
283 | if (sysctl(mib, 4, &oldstate, &sz, NULL, 0) == -1) |
284 | goto bad; |
285 | if (oldstate == state) |
286 | return; |
287 | if (sysctl(mib, 4, NULL, NULL, &state, sz) >= 0) |
288 | return; |
289 | } else if (kvm_write(kvp->kd, (u_long)&p->state, (void *)&state, sz) |
290 | == sz) |
291 | return; |
292 | bad: |
293 | warnx("warning: cannot turn profiling %s", |
294 | state == GMON_PROF_OFF ? "off" : "on"); |
295 | } |
296 | |
297 | |
298 | |
299 | |
300 | void |
301 | dumpstate(struct kvmvars *kvp, int cpuid) |
302 | { |
303 | FILE *fp; |
304 | struct rawarc rawarc; |
305 | struct tostruct *tos; |
306 | u_long frompc; |
307 | u_short *froms, *tickbuf; |
308 | int mib[4]; |
309 | size_t i; |
310 | struct gmonhdr h; |
311 | int fromindex, endfrom, toindex; |
312 | char buf[16]; |
313 | |
314 | snprintf(buf, sizeof(buf), "gmon-%02d.out", cpuid); |
315 | |
316 | setprof(kvp, cpuid, GMON_PROF_OFF); |
317 | fp = fopen(buf, "w"); |
318 | if (fp == 0) { |
319 | perror(buf); |
320 | return; |
321 | } |
322 | |
323 | |
324 | |
325 | |
326 | bzero(&h, sizeof(h)); |
327 | h.lpc = kvp->gpm.lowpc; |
328 | h.hpc = kvp->gpm.highpc; |
329 | h.ncnt = kvp->gpm.kcountsize + sizeof(h); |
330 | h.version = GMONVERSION; |
331 | h.profrate = getprofhz(kvp); |
332 | fwrite((char *)&h, sizeof(h), 1, fp); |
333 | |
334 | |
335 | |
336 | |
337 | mib[0] = CTL_KERN; |
338 | mib[1] = KERN_PROF; |
339 | if ((tickbuf = malloc(kvp->gpm.kcountsize)) == NULL) |
340 | errx(5, "cannot allocate kcount space"); |
341 | if (kflag) { |
342 | i = kvm_read(kvp->kd, (u_long)kvp->gpm.kcount, (void *)tickbuf, |
343 | kvp->gpm.kcountsize); |
344 | } else { |
345 | mib[2] = GPROF_COUNT; |
346 | mib[3] = cpuid; |
347 | i = kvp->gpm.kcountsize; |
348 | if (sysctl(mib, 4, tickbuf, &i, NULL, 0) == -1) |
349 | i = 0; |
350 | } |
351 | if (i != kvp->gpm.kcountsize) |
352 | errx(6, "read ticks: read %lu, got %zu: %s", |
353 | kvp->gpm.kcountsize, i, |
354 | kflag ? kvm_geterr(kvp->kd) : strerror(errno)); |
355 | if ((fwrite(tickbuf, kvp->gpm.kcountsize, 1, fp)) != 1) |
356 | err(7, "writing tocks to gmon.out"); |
357 | free(tickbuf); |
358 | |
359 | |
360 | |
361 | |
362 | if ((froms = malloc(kvp->gpm.fromssize)) == NULL) |
363 | errx(8, "cannot allocate froms space"); |
364 | if (kflag) { |
365 | i = kvm_read(kvp->kd, (u_long)kvp->gpm.froms, (void *)froms, |
366 | kvp->gpm.fromssize); |
367 | } else { |
368 | mib[2] = GPROF_FROMS; |
369 | mib[3] = cpuid; |
370 | i = kvp->gpm.fromssize; |
371 | if (sysctl(mib, 4, froms, &i, NULL, 0) == -1) |
372 | i = 0; |
373 | } |
374 | if (i != kvp->gpm.fromssize) |
375 | errx(9, "read froms: read %lu, got %zu: %s", |
376 | kvp->gpm.fromssize, i, |
377 | kflag ? kvm_geterr(kvp->kd) : strerror(errno)); |
378 | if ((tos = malloc(kvp->gpm.tossize)) == NULL) |
379 | errx(10, "cannot allocate tos space"); |
380 | if (kflag) { |
381 | i = kvm_read(kvp->kd, (u_long)kvp->gpm.tos, (void *)tos, |
382 | kvp->gpm.tossize); |
383 | } else { |
384 | mib[2] = GPROF_TOS; |
385 | mib[3] = cpuid; |
386 | i = kvp->gpm.tossize; |
387 | if (sysctl(mib, 4, tos, &i, NULL, 0) == -1) |
388 | i = 0; |
389 | } |
390 | if (i != kvp->gpm.tossize) |
391 | errx(11, "read tos: read %lu, got %zu: %s", |
392 | kvp->gpm.tossize, i, |
393 | kflag ? kvm_geterr(kvp->kd) : strerror(errno)); |
394 | if (debug) |
395 | warnx("lowpc 0x%lx, textsize 0x%lx", |
396 | kvp->gpm.lowpc, kvp->gpm.textsize); |
397 | endfrom = kvp->gpm.fromssize / sizeof(*froms); |
398 | for (fromindex = 0; fromindex < endfrom; ++fromindex) { |
399 | if (froms[fromindex] == 0) |
400 | continue; |
401 | frompc = (u_long)kvp->gpm.lowpc + |
402 | (fromindex * kvp->gpm.hashfraction * sizeof(*froms)); |
403 | for (toindex = froms[fromindex]; toindex != 0; |
404 | toindex = tos[toindex].link) { |
405 | if (debug) |
406 | warnx("[mcleanup] frompc 0x%lx selfpc 0x%lx count %ld", |
407 | frompc, tos[toindex].selfpc, tos[toindex].count); |
408 | rawarc.raw_frompc = frompc; |
409 | rawarc.raw_selfpc = (u_long)tos[toindex].selfpc; |
410 | rawarc.raw_count = tos[toindex].count; |
411 | fwrite((char *)&rawarc, sizeof(rawarc), 1, fp); |
412 | } |
413 | } |
414 | fclose(fp); |
415 | } |
416 | |
417 | |
418 | |
419 | |
420 | int |
421 | getprofhz(struct kvmvars *kvp) |
422 | { |
423 | int mib[2], profrate; |
424 | size_t size; |
425 | struct clockinfo clockrate; |
426 | |
427 | if (kflag) { |
428 | profrate = 1; |
429 | if (kvm_read(kvp->kd, nl[N_PROFHZ].n_value, &profrate, |
430 | sizeof profrate) != sizeof profrate) |
431 | warnx("get clockrate: %s", kvm_geterr(kvp->kd)); |
432 | return (profrate); |
433 | } |
434 | mib[0] = CTL_KERN; |
435 | mib[1] = KERN_CLOCKRATE; |
436 | clockrate.profhz = 1; |
437 | size = sizeof clockrate; |
438 | if (sysctl(mib, 2, &clockrate, &size, NULL, 0) == -1) |
439 | warn("get clockrate"); |
440 | return (clockrate.profhz); |
441 | } |
442 | |
443 | |
444 | |
445 | |
446 | void |
447 | reset(struct kvmvars *kvp, int cpuid) |
448 | { |
449 | char *zbuf; |
450 | u_long biggest; |
451 | int mib[4]; |
452 | |
453 | setprof(kvp, cpuid, GMON_PROF_OFF); |
454 | |
455 | biggest = kvp->gpm.kcountsize; |
456 | if (kvp->gpm.fromssize > biggest) |
| 15 | | Assuming 'biggest' is >= field 'fromssize' | |
|
| |
457 | biggest = kvp->gpm.fromssize; |
458 | if (kvp->gpm.tossize > biggest) |
| 17 | | Assuming 'biggest' is >= field 'tossize' | |
|
| |
459 | biggest = kvp->gpm.tossize; |
460 | if ((zbuf = malloc(biggest)) == NULL) |
| |
| 20 | | Assuming the condition is false | |
|
| |
461 | errx(12, "cannot allocate zbuf space"); |
462 | bzero(zbuf, biggest); |
463 | if (kflag) { |
| 22 | | Assuming 'kflag' is not equal to 0 | |
|
| |
464 | if (kvm_write(kvp->kd, (u_long)kvp->gpm.kcount, zbuf, |
| 24 | | Assuming the condition is false | |
|
| |
465 | kvp->gpm.kcountsize) != kvp->gpm.kcountsize) |
466 | errx(13, "tickbuf zero: %s", kvm_geterr(kvp->kd)); |
467 | if (kvm_write(kvp->kd, (u_long)kvp->gpm.froms, zbuf, |
| 26 | | Assuming the condition is false | |
|
| |
468 | kvp->gpm.fromssize) != kvp->gpm.fromssize) |
469 | errx(14, "froms zero: %s", kvm_geterr(kvp->kd)); |
470 | if (kvm_write(kvp->kd, (u_long)kvp->gpm.tos, zbuf, |
| 28 | | Assuming the condition is false | |
|
| |
471 | kvp->gpm.tossize) != kvp->gpm.tossize) |
472 | errx(15, "tos zero: %s", kvm_geterr(kvp->kd)); |
473 | return; |
| 30 | | Potential leak of memory pointed to by 'zbuf' |
|
474 | } |
475 | mib[0] = CTL_KERN; |
476 | mib[1] = KERN_PROF; |
477 | mib[2] = GPROF_COUNT; |
478 | mib[3] = cpuid; |
479 | if (sysctl(mib, 4, NULL, NULL, zbuf, kvp->gpm.kcountsize) == -1) |
480 | err(13, "tickbuf zero"); |
481 | mib[2] = GPROF_FROMS; |
482 | if (sysctl(mib, 4, NULL, NULL, zbuf, kvp->gpm.fromssize) == -1) |
483 | err(14, "froms zero"); |
484 | mib[2] = GPROF_TOS; |
485 | if (sysctl(mib, 4, NULL, NULL, zbuf, kvp->gpm.tossize) == -1) |
486 | err(15, "tos zero"); |
487 | free(zbuf); |
488 | } |
489 | |
490 | int |
491 | getncpu(void) |
492 | { |
493 | int mib[2] = { CTL_HW, HW_NCPU }; |
494 | size_t size; |
495 | int ncpu; |
496 | |
497 | size = sizeof(ncpu); |
498 | if (sysctl(mib, 2, &ncpu, &size, NULL, 0) == -1) { |
499 | warnx("cannot read hw.ncpu"); |
500 | return (1); |
501 | } |
502 | |
503 | return (ncpu); |
504 | } |