1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2025 The FreeBSD Foundation
5 *
6 * This software was developed by Konstantin Belousov <kib@FreeBSD.org>
7 * under sponsorship from the FreeBSD Foundation.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include <sys/param.h>
32 #include <sys/event.h>
33 #include <sys/sysctl.h>
34 #include <sys/user.h>
35
36 #include <err.h>
37 #include <errno.h>
38 #include <libprocstat.h>
39 #include <stdbool.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <stdint.h>
43 #include <string.h>
44
45 #include "procstat.h"
46
47 static const char kqs[] = "kqueues";
48 static const char kq[] = "kqueue";
49
50 #define FILT_ELEM(name) [-EVFILT_##name] = #name,
51 static const char *const filter_names[] = {
52 [0] = "invalid",
53 FILT_ELEM(READ)
54 FILT_ELEM(WRITE)
55 FILT_ELEM(AIO)
56 FILT_ELEM(VNODE)
57 FILT_ELEM(PROC)
58 FILT_ELEM(SIGNAL)
59 FILT_ELEM(TIMER)
60 FILT_ELEM(PROCDESC)
61 FILT_ELEM(FS)
62 FILT_ELEM(LIO)
63 FILT_ELEM(USER)
64 FILT_ELEM(SENDFILE)
65 FILT_ELEM(EMPTY)
66 };
67 #undef FILT_ELEM
68
69 #define PK_FLAG_ELEM(fname, str) { .flag = fname, .dispstr = str }
70 #define PK_NAME_ELEM(prefix, fname) { .flag = prefix##fname, .dispstr = #fname }
71 #define PK_FLAG_LAST_ELEM() { .flag = -1, .dispstr = NULL }
72 struct pk_elem {
73 unsigned int flag;
74 const char *dispstr;
75 };
76
77 static const struct pk_elem kn_status_names[] = {
78 PK_FLAG_ELEM(KNOTE_STATUS_ACTIVE, "A"),
79 PK_FLAG_ELEM(KNOTE_STATUS_QUEUED, "Q"),
80 PK_FLAG_ELEM(KNOTE_STATUS_DISABLED, "D"),
81 PK_FLAG_ELEM(KNOTE_STATUS_DETACHED, "d"),
82 PK_FLAG_ELEM(KNOTE_STATUS_KQUEUE, "K"),
83 PK_FLAG_LAST_ELEM(),
84 };
85
86 static const struct pk_elem ev_flags_names[] = {
87 PK_FLAG_ELEM(EV_ONESHOT, "O"),
88 PK_FLAG_ELEM(EV_CLEAR, "C"),
89 PK_FLAG_ELEM(EV_RECEIPT, "R"),
90 PK_FLAG_ELEM(EV_DISPATCH, "D"),
91 PK_FLAG_ELEM(EV_DROP, "d"),
92 PK_FLAG_ELEM(EV_FLAG1, "1"),
93 PK_FLAG_ELEM(EV_FLAG2, "2"),
94 PK_FLAG_LAST_ELEM(),
95 };
96
97 static char *
procstat_kqueue_flags(const struct pk_elem * names,unsigned flags,bool commas)98 procstat_kqueue_flags(const struct pk_elem *names, unsigned flags, bool commas)
99 {
100 char *res;
101 const struct pk_elem *pl;
102 size_t len;
103 int i;
104 bool first;
105
106 first = true;
107 len = 0;
108 for (i = 0;; i++) {
109 pl = &names[i];
110 if (pl->flag == (unsigned)-1)
111 break;
112 if ((flags & pl->flag) != 0) {
113 if (first)
114 first = false;
115 else if (commas)
116 len += sizeof(",");
117 len += strlen(pl->dispstr);
118 }
119 }
120 len++;
121
122 res = malloc(len);
123 first = true;
124 res[0] = '\0';
125 for (i = 0;; i++) {
126 pl = &names[i];
127 if (pl->flag == (unsigned)-1)
128 break;
129 if ((flags & pl->flag) != 0) {
130 if (first)
131 first = false;
132 else if (commas)
133 strlcat(res, ",", len);
134 strlcat(res, pl->dispstr, len);
135 }
136 }
137
138 if (strlen(res) == 0)
139 return (strdup("-"));
140 return (res);
141 }
142
143 static const struct pk_elem rw_filter_names[] = {
144 PK_NAME_ELEM(NOTE_, LOWAT),
145 PK_NAME_ELEM(NOTE_, FILE_POLL),
146 PK_FLAG_LAST_ELEM(),
147 };
148
149 static const struct pk_elem user_filter_names[] = {
150 PK_NAME_ELEM(NOTE_, FFAND),
151 PK_NAME_ELEM(NOTE_, FFOR),
152 PK_NAME_ELEM(NOTE_, TRIGGER),
153 PK_FLAG_LAST_ELEM(),
154 };
155
156 static const struct pk_elem vnode_filter_names[] = {
157 PK_NAME_ELEM(NOTE_, DELETE),
158 PK_NAME_ELEM(NOTE_, WRITE),
159 PK_NAME_ELEM(NOTE_, EXTEND),
160 PK_NAME_ELEM(NOTE_, ATTRIB),
161 PK_NAME_ELEM(NOTE_, LINK),
162 PK_NAME_ELEM(NOTE_, RENAME),
163 PK_NAME_ELEM(NOTE_, REVOKE),
164 PK_NAME_ELEM(NOTE_, OPEN),
165 PK_NAME_ELEM(NOTE_, CLOSE),
166 PK_NAME_ELEM(NOTE_, CLOSE_WRITE),
167 PK_NAME_ELEM(NOTE_, READ),
168 PK_FLAG_LAST_ELEM(),
169 };
170
171 static const struct pk_elem proc_filter_names[] = {
172 PK_NAME_ELEM(NOTE_, EXIT),
173 PK_NAME_ELEM(NOTE_, FORK),
174 PK_NAME_ELEM(NOTE_, EXEC),
175 PK_NAME_ELEM(NOTE_, TRACK),
176 PK_NAME_ELEM(NOTE_, TRACKERR),
177 PK_NAME_ELEM(NOTE_, CHILD),
178 PK_FLAG_LAST_ELEM(),
179 };
180
181 static const struct pk_elem timer_filter_names[] = {
182 PK_NAME_ELEM(NOTE_, SECONDS),
183 PK_NAME_ELEM(NOTE_, MSECONDS),
184 PK_NAME_ELEM(NOTE_, USECONDS),
185 PK_NAME_ELEM(NOTE_, NSECONDS),
186 PK_NAME_ELEM(NOTE_, ABSTIME),
187 PK_FLAG_LAST_ELEM(),
188 };
189
190 #define FILT_ELEM(name) [-EVFILT_##name] = "EVFILT_"#name
191 static const struct pk_elem *const filter_pk_names[] = {
192 [0] = NULL,
193 [-EVFILT_READ] = rw_filter_names,
194 [-EVFILT_WRITE] = rw_filter_names,
195 [-EVFILT_AIO] = rw_filter_names,
196 [-EVFILT_VNODE] = vnode_filter_names,
197 [-EVFILT_PROC] = proc_filter_names,
198 [-EVFILT_SIGNAL] = NULL,
199 [-EVFILT_TIMER] = timer_filter_names,
200 [-EVFILT_PROCDESC] = proc_filter_names,
201 [-EVFILT_FS] = NULL,
202 [-EVFILT_LIO] = rw_filter_names,
203 [-EVFILT_USER] = user_filter_names,
204 [-EVFILT_SENDFILE] = NULL,
205 [-EVFILT_EMPTY] = NULL,
206 };
207
208 static char *
procstat_kqueue_fflags(int filter,unsigned fflags)209 procstat_kqueue_fflags(int filter, unsigned fflags)
210 {
211 const struct pk_elem *names;
212
213 names = NULL;
214 if (filter < 0 && -filter < (int)nitems(filter_pk_names))
215 names = filter_pk_names[-filter];
216 if (names == NULL)
217 return (strdup("-"));
218 return (procstat_kqueue_flags(names, fflags, true));
219 }
220
221 static const char *
procstat_kqueue_get_filter_name(int filter)222 procstat_kqueue_get_filter_name(int filter)
223 {
224 filter = -filter;
225 if (filter < 0 || filter >= (int)nitems(filter_names))
226 filter = 0;
227 return (filter_names[filter]);
228 }
229
230 static void
procstat_kqueue(struct procstat * procstat,struct kinfo_proc * kipp,int fd,bool verbose)231 procstat_kqueue(struct procstat *procstat, struct kinfo_proc *kipp, int fd,
232 bool verbose)
233 {
234 struct kinfo_knote *kni, *knis;
235 char *flags, *fflags, *status;
236 unsigned int count, i, j;
237 char errbuf[_POSIX2_LINE_MAX];
238
239 errbuf[0] = '\0';
240 knis = procstat_get_kqueue_info(procstat, kipp, fd, &count, errbuf);
241 if (knis == NULL) {
242 warnx("%s\n", errbuf);
243 return;
244 }
245
246 for (i = 0; i < count; i++) {
247 kni = &knis[i];
248 flags = procstat_kqueue_flags(ev_flags_names,
249 kni->knt_event.flags, false);
250 fflags = procstat_kqueue_fflags(kni->knt_event.filter,
251 kni->knt_event.fflags);
252 status = procstat_kqueue_flags(kn_status_names,
253 kni->knt_status, false);
254 xo_open_instance(kq);
255 xo_emit("{dk:process_id/%7d} ", kipp->ki_pid);
256 xo_emit("{:kqueue_fd/%10d} ", fd);
257 xo_emit("{:filter/%8s} ", procstat_kqueue_get_filter_name(
258 kni->knt_event.filter));
259 xo_emit("{:ident/%10d} ", kni->knt_event.ident);
260 xo_emit("{:flags/%10s} ", flags);
261 xo_emit("{:fflags/%10s} ", fflags);
262 xo_emit("{:data/%#10jx} ", (uintmax_t)kni->knt_event.data);
263 xo_emit("{:udata/%10p} ", (uintmax_t)kni->knt_event.udata);
264 if (verbose) {
265 for (j = 0; j < nitems(kni->knt_event.ext); j++) {
266 xo_emit("{:ext%u/%#10jx} ", j,
267 (uintmax_t)kni->knt_event.ext[j]);
268 }
269 }
270 xo_emit("{:status/%10s}\n", status);
271 free(flags);
272 free(fflags);
273 free(status);
274 xo_close_instance(kq);
275 }
276
277 procstat_freekqinfo(procstat, knis);
278 }
279
280 void
procstat_kqueues(struct procstat * procstat,struct kinfo_proc * kipp)281 procstat_kqueues(struct procstat *procstat, struct kinfo_proc *kipp)
282 {
283 struct filestat_list *fl;
284 struct filestat *f;
285 bool verbose;
286
287 verbose = (procstat_opts & PS_OPT_VERBOSE) != 0;
288 if ((procstat_opts & PS_OPT_NOHEADER) == 0) {
289 if (verbose) {
290 xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s "
291 "%10s %10s %10s %10s %10s}\n",
292 "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS",
293 "DATA", "UDATA", "EXT0", "EXT1","EXT2","EXT3",
294 "STATUS");
295 } else {
296 xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s "
297 "%10s}\n",
298 "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS",
299 "DATA", "UDATA", "STATUS");
300 }
301 }
302
303 xo_emit("{ek:process_id/%d}", kipp->ki_pid);
304
305 fl = procstat_getfiles(procstat, kipp, 0);
306 if (fl == NULL)
307 return;
308 xo_open_list(kqs);
309 STAILQ_FOREACH(f, fl, next) {
310 if (f->fs_type != PS_FST_TYPE_KQUEUE)
311 continue;
312 xo_emit("{ek:kqueue/%d}", f->fs_fd);
313 xo_open_list(kq);
314 procstat_kqueue(procstat, kipp, f->fs_fd, verbose);
315 xo_close_list(kq);
316 }
317 xo_close_list(kqs);
318 procstat_freefiles(procstat, fl);
319 }
320