xref: /freebsd/lib/libpmc/libpmc_json.cc (revision 0957b409)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2018, Matthew Macy
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25  * SUCH DAMAGE.
26  *
27  * $FreeBSD$
28  *
29  */
30 
31 #include <sys/types.h>
32 #include <sys/errno.h>
33 #include <sys/sysctl.h>
34 #include <stddef.h>
35 #include <stdlib.h>
36 #include <err.h>
37 #include <limits.h>
38 #include <string.h>
39 #include <pmc.h>
40 #include <pmclog.h>
41 #include <assert.h>
42 #include <string>
43 #include <sysexits.h>
44 #include <pmcformat.h>
45 
46 using std::string;
47 
48 static const char *typenames[] = {
49 	"",
50 	"{\"type\": \"closelog\"}\n",
51 	"{\"type\": \"dropnotify\"}\n",
52 	"{\"type\": \"initialize\"",
53 	"",
54 	"{\"type\": \"pmcallocate\"",
55 	"{\"type\": \"pmcattach\"",
56 	"{\"type\": \"pmcdetach\"",
57 	"{\"type\": \"proccsw\"",
58 	"{\"type\": \"procexec\"",
59 	"{\"type\": \"procexit\"",
60 	"{\"type\": \"procfork\"",
61 	"{\"type\": \"sysexit\"",
62 	"{\"type\": \"userdata\"",
63 	"{\"type\": \"map_in\"",
64 	"{\"type\": \"map_out\"",
65 	"{\"type\": \"callchain\"",
66 	"{\"type\": \"pmcallocatedyn\"",
67 	"{\"type\": \"thr_create\"",
68 	"{\"type\": \"thr_exit\"",
69 	"{\"type\": \"proc_create\"",
70 };
71 
72 static string
73 startentry(struct pmclog_ev *ev)
74 {
75 	char eventbuf[128];
76 
77 	snprintf(eventbuf, sizeof(eventbuf), "%s, \"tsc\": \"%jd\"",
78 	    typenames[ev->pl_type], (uintmax_t)ev->pl_ts.tv_sec);
79 	return (string(eventbuf));
80 }
81 
82 static string
83 initialize_to_json(struct pmclog_ev *ev)
84 {
85 	char eventbuf[256];
86 	string startent;
87 
88 	startent = startentry(ev);
89 	snprintf(eventbuf, sizeof(eventbuf),
90 	    "%s, \"version\": \"0x%08x\", \"arch\": \"0x%08x\", \"cpuid\": \"%s\", "
91 		"\"tsc_freq\": \"%jd\", \"sec\": \"%jd\", \"nsec\": \"%jd\"}\n",
92 		startent.c_str(), ev->pl_u.pl_i.pl_version, ev->pl_u.pl_i.pl_arch,
93 		ev->pl_u.pl_i.pl_cpuid, (uintmax_t)ev->pl_u.pl_i.pl_tsc_freq,
94 		(uintmax_t)ev->pl_u.pl_i.pl_ts.tv_sec, (uintmax_t)ev->pl_u.pl_i.pl_ts.tv_nsec);
95 	return string(eventbuf);
96 }
97 
98 static string
99 pmcallocate_to_json(struct pmclog_ev *ev)
100 {
101 	char eventbuf[256];
102 	string startent;
103 
104 	startent = startentry(ev);
105 	snprintf(eventbuf, sizeof(eventbuf),
106 	    "%s, \"pmcid\": \"0x%08x\", \"event\": \"0x%08x\", \"flags\": \"0x%08x\", "
107 	    "\"rate\": \"%jd\"}\n",
108 		startent.c_str(), ev->pl_u.pl_a.pl_pmcid, ev->pl_u.pl_a.pl_event,
109 	    ev->pl_u.pl_a.pl_flags, (intmax_t)ev->pl_u.pl_a.pl_rate);
110 	return string(eventbuf);
111 }
112 
113 static string
114 pmcattach_to_json(struct pmclog_ev *ev)
115 {
116 	char eventbuf[2048];
117 	string startent;
118 
119 	startent = startentry(ev);
120 	snprintf(eventbuf, sizeof(eventbuf),
121 	    "%s, \"pmcid\": \"0x%08x\", \"pid\": \"%d\", \"pathname\": \"%s\"}\n",
122 		startent.c_str(), ev->pl_u.pl_t.pl_pmcid, ev->pl_u.pl_t.pl_pid,
123 	    ev->pl_u.pl_t.pl_pathname);
124 	return string(eventbuf);
125 }
126 
127 static string
128 pmcdetach_to_json(struct pmclog_ev *ev)
129 {
130 	char eventbuf[128];
131 	string startent;
132 
133 	startent = startentry(ev);
134 	snprintf(eventbuf, sizeof(eventbuf),
135 		"%s, \"pmcid\": \"0x%08x\", \"pid\": \"%d\"}\n",
136 			 startent.c_str(), ev->pl_u.pl_d.pl_pmcid, ev->pl_u.pl_d.pl_pid);
137 	return string(eventbuf);
138 }
139 
140 
141 static string
142 proccsw_to_json(struct pmclog_ev *ev)
143 {
144 	char eventbuf[128];
145 	string startent;
146 
147 	startent = startentry(ev);
148 	snprintf(eventbuf, sizeof(eventbuf), "%s, \"pmcid\": \"0x%08x\", \"pid\": \"%d\" "
149 	    "\"tid\": \"%d\", \"value\": \"0x%016jx\"}\n",
150 		startent.c_str(), ev->pl_u.pl_c.pl_pmcid, ev->pl_u.pl_c.pl_pid,
151 	    ev->pl_u.pl_c.pl_tid, (uintmax_t)ev->pl_u.pl_c.pl_value);
152 	return string(eventbuf);
153 }
154 
155 static string
156 procexec_to_json(struct pmclog_ev *ev)
157 {
158 	char eventbuf[2048];
159 	string startent;
160 
161 	startent = startentry(ev);
162 	snprintf(eventbuf, sizeof(eventbuf),
163 		"%s, \"pmcid\": \"0x%08x\", \"pid\": \"%d\", "
164 	    "\"start\": \"0x%016jx\", \"pathname\": \"%s\"}\n",
165 		startent.c_str(), ev->pl_u.pl_x.pl_pmcid, ev->pl_u.pl_x.pl_pid,
166 		(uintmax_t)ev->pl_u.pl_x.pl_entryaddr, ev->pl_u.pl_x.pl_pathname);
167 	return string(eventbuf);
168 }
169 
170 static string
171 procexit_to_json(struct pmclog_ev *ev)
172 {
173 	char eventbuf[128];
174 	string startent;
175 
176 	startent = startentry(ev);
177 	snprintf(eventbuf, sizeof(eventbuf),
178 		"%s, \"pmcid\": \"0x%08x\", \"pid\": \"%d\", "
179 	    "\"value\": \"0x%016jx\"}\n",
180 		startent.c_str(), ev->pl_u.pl_e.pl_pmcid, ev->pl_u.pl_e.pl_pid,
181 	    (uintmax_t)ev->pl_u.pl_e.pl_value);
182 	return string(eventbuf);
183 }
184 
185 static string
186 procfork_to_json(struct pmclog_ev *ev)
187 {
188 	char eventbuf[128];
189 	string startent;
190 
191 	startent = startentry(ev);
192 	snprintf(eventbuf, sizeof(eventbuf),
193 		"%s, \"oldpid\": \"%d\", \"newpid\": \"%d\"}\n",
194 		startent.c_str(), ev->pl_u.pl_f.pl_oldpid, ev->pl_u.pl_f.pl_newpid);
195 	return string(eventbuf);
196 }
197 
198 static string
199 sysexit_to_json(struct pmclog_ev *ev)
200 {
201 	char eventbuf[128];
202 	string startent;
203 
204 	startent = startentry(ev);
205 	snprintf(eventbuf, sizeof(eventbuf), "%s, \"pid\": \"%d\"}\n",
206 		startent.c_str(), ev->pl_u.pl_se.pl_pid);
207 	return string(eventbuf);
208 }
209 
210 static string
211 userdata_to_json(struct pmclog_ev *ev)
212 {
213 	char eventbuf[128];
214 	string startent;
215 
216 	startent = startentry(ev);
217 	snprintf(eventbuf, sizeof(eventbuf), "%s, \"userdata\": \"0x%08x\"}\n",
218 	    startent.c_str(), ev->pl_u.pl_u.pl_userdata);
219 	return string(eventbuf);
220 }
221 
222 static string
223 map_in_to_json(struct pmclog_ev *ev)
224 {
225 	char eventbuf[2048];
226 	string startent;
227 
228 	startent = startentry(ev);
229 	snprintf(eventbuf, sizeof(eventbuf), "%s, \"pid\": \"%d\", "
230 	    "\"start\": \"0x%016jx\", \"pathname\": \"%s\"}\n",
231 	    startent.c_str(), ev->pl_u.pl_mi.pl_pid,
232 	    (uintmax_t)ev->pl_u.pl_mi.pl_start, ev->pl_u.pl_mi.pl_pathname);
233 	return string(eventbuf);
234 }
235 
236 static string
237 map_out_to_json(struct pmclog_ev *ev)
238 {
239 	char eventbuf[256];
240 	string startent;
241 
242 	startent = startentry(ev);
243 	snprintf(eventbuf, sizeof(eventbuf), "%s, \"pid\": \"%d\", "
244 	    "\"start\": \"0x%016jx\", \"end\": \"0x%016jx\"}\n",
245 	    startent.c_str(), ev->pl_u.pl_mi.pl_pid,
246 	    (uintmax_t)ev->pl_u.pl_mi.pl_start,
247 	    (uintmax_t)ev->pl_u.pl_mo.pl_end);
248 	return string(eventbuf);
249 }
250 
251 static string
252 callchain_to_json(struct pmclog_ev *ev)
253 {
254 	char eventbuf[1024];
255 	string result;
256 	uint32_t i;
257 	string startent;
258 
259 	startent = startentry(ev);
260 	snprintf(eventbuf, sizeof(eventbuf),
261 	    "%s, \"pmcid\": \"0x%08x\", \"pid\": \"%d\", \"tid\": \"%d\", "
262 	    "\"cpuflags\": \"0x%08x\", \"cpuflags2\": \"0x%08x\", \"pc\": [ ",
263 		startent.c_str(), ev->pl_u.pl_cc.pl_pmcid, ev->pl_u.pl_cc.pl_pid,
264 	    ev->pl_u.pl_cc.pl_tid, ev->pl_u.pl_cc.pl_cpuflags, ev->pl_u.pl_cc.pl_cpuflags2);
265 	result = string(eventbuf);
266 	for (i = 0; i < ev->pl_u.pl_cc.pl_npc - 1; i++) {
267 		snprintf(eventbuf, sizeof(eventbuf), "\"0x%016jx\", ", (uintmax_t)ev->pl_u.pl_cc.pl_pc[i]);
268 		result += string(eventbuf);
269 	}
270 	snprintf(eventbuf, sizeof(eventbuf), "\"0x%016jx\"]}\n", (uintmax_t)ev->pl_u.pl_cc.pl_pc[i]);
271 	result += string(eventbuf);
272 	return (result);
273 }
274 
275 static string
276 pmcallocatedyn_to_json(struct pmclog_ev *ev)
277 {
278 	char eventbuf[2048];
279 	string startent;
280 
281 	startent = startentry(ev);
282 	snprintf(eventbuf, sizeof(eventbuf),
283 	    "%s, \"pmcid\": \"0x%08x\", \"event\": \"%d\", \"flags\": \"0x%08x\", \"evname\": \"%s\"}\n",
284 	    startent.c_str(), ev->pl_u.pl_ad.pl_pmcid, ev->pl_u.pl_ad.pl_event,
285 	    ev->pl_u.pl_ad.pl_flags, ev->pl_u.pl_ad.pl_evname);
286 	return string(eventbuf);
287 }
288 
289 static string
290 proccreate_to_json(struct pmclog_ev *ev)
291 {
292 	char eventbuf[2048];
293 	string startent;
294 
295 	startent = startentry(ev);
296 	snprintf(eventbuf, sizeof(eventbuf),
297 	    "%s, \"pid\": \"%d\", \"flags\": \"0x%08x\", \"pcomm\": \"%s\"}\n",
298 	    startent.c_str(), ev->pl_u.pl_pc.pl_pid,
299 	    ev->pl_u.pl_pc.pl_flags, ev->pl_u.pl_pc.pl_pcomm);
300 	return string(eventbuf);
301 }
302 
303 static string
304 threadcreate_to_json(struct pmclog_ev *ev)
305 {
306 	char eventbuf[2048];
307 	string startent;
308 
309 	startent = startentry(ev);
310 	snprintf(eventbuf, sizeof(eventbuf),
311 	    "%s, \"tid\": \"%d\", \"pid\": \"%d\", \"flags\": \"0x%08x\", \"tdname\": \"%s\"}\n",
312 	    startent.c_str(), ev->pl_u.pl_tc.pl_tid, ev->pl_u.pl_tc.pl_pid,
313 	    ev->pl_u.pl_tc.pl_flags, ev->pl_u.pl_tc.pl_tdname);
314 	return string(eventbuf);
315 }
316 
317 static string
318 threadexit_to_json(struct pmclog_ev *ev)
319 {
320 	char eventbuf[256];
321 	string startent;
322 
323 	startent = startentry(ev);
324 	snprintf(eventbuf, sizeof(eventbuf), "%s, \"tid\": \"%d\"}\n",
325 	    startent.c_str(), ev->pl_u.pl_te.pl_tid);
326 	return string(eventbuf);
327 }
328 
329 static string
330 stub_to_json(struct pmclog_ev *ev)
331 {
332 	string startent;
333 
334 	startent = startentry(ev);
335 	startent += string("}\n");
336 	return startent;
337 }
338 
339 typedef string (*jconv) (struct pmclog_ev*);
340 
341 static jconv jsonconvert[] = {
342 	NULL,
343 	stub_to_json,
344 	stub_to_json,
345 	initialize_to_json,
346 	NULL,
347 	pmcallocate_to_json,
348 	pmcattach_to_json,
349 	pmcdetach_to_json,
350 	proccsw_to_json,
351 	procexec_to_json,
352 	procexit_to_json,
353 	procfork_to_json,
354 	sysexit_to_json,
355 	userdata_to_json,
356 	map_in_to_json,
357 	map_out_to_json,
358 	callchain_to_json,
359 	pmcallocatedyn_to_json,
360 	threadcreate_to_json,
361 	threadexit_to_json,
362 	proccreate_to_json,
363 };
364 
365 string
366 event_to_json(struct pmclog_ev *ev){
367 
368 	switch (ev->pl_type) {
369 	case PMCLOG_TYPE_DROPNOTIFY:
370 	case PMCLOG_TYPE_CLOSELOG:
371 	case PMCLOG_TYPE_INITIALIZE:
372 	case PMCLOG_TYPE_PMCALLOCATE:
373 	case PMCLOG_TYPE_PMCATTACH:
374 	case PMCLOG_TYPE_PMCDETACH:
375 	case PMCLOG_TYPE_PROCCSW:
376 	case PMCLOG_TYPE_PROCEXEC:
377 	case PMCLOG_TYPE_PROCEXIT:
378 	case PMCLOG_TYPE_PROCFORK:
379 	case PMCLOG_TYPE_SYSEXIT:
380 	case PMCLOG_TYPE_USERDATA:
381 	case PMCLOG_TYPE_MAP_IN:
382 	case PMCLOG_TYPE_MAP_OUT:
383 	case PMCLOG_TYPE_CALLCHAIN:
384 	case PMCLOG_TYPE_PMCALLOCATEDYN:
385 	case PMCLOG_TYPE_THR_CREATE:
386 	case PMCLOG_TYPE_THR_EXIT:
387 	case PMCLOG_TYPE_PROC_CREATE:
388 		return jsonconvert[ev->pl_type](ev);
389 	default:
390 		errx(EX_USAGE, "ERROR: unrecognized event type: %d\n", ev->pl_type);
391 	}
392 }
393 
394