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 * 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 free(res); 140 res = strdup("-"); 141 } 142 return (res); 143 } 144 145 static const struct pk_elem rw_filter_names[] = { 146 PK_NAME_ELEM(NOTE_, LOWAT), 147 PK_NAME_ELEM(NOTE_, FILE_POLL), 148 PK_FLAG_LAST_ELEM(), 149 }; 150 151 static const struct pk_elem user_filter_names[] = { 152 PK_NAME_ELEM(NOTE_, FFAND), 153 PK_NAME_ELEM(NOTE_, FFOR), 154 PK_NAME_ELEM(NOTE_, TRIGGER), 155 PK_FLAG_LAST_ELEM(), 156 }; 157 158 static const struct pk_elem vnode_filter_names[] = { 159 PK_NAME_ELEM(NOTE_, DELETE), 160 PK_NAME_ELEM(NOTE_, WRITE), 161 PK_NAME_ELEM(NOTE_, EXTEND), 162 PK_NAME_ELEM(NOTE_, ATTRIB), 163 PK_NAME_ELEM(NOTE_, LINK), 164 PK_NAME_ELEM(NOTE_, RENAME), 165 PK_NAME_ELEM(NOTE_, REVOKE), 166 PK_NAME_ELEM(NOTE_, OPEN), 167 PK_NAME_ELEM(NOTE_, CLOSE), 168 PK_NAME_ELEM(NOTE_, CLOSE_WRITE), 169 PK_NAME_ELEM(NOTE_, READ), 170 PK_FLAG_LAST_ELEM(), 171 }; 172 173 static const struct pk_elem proc_filter_names[] = { 174 PK_NAME_ELEM(NOTE_, EXIT), 175 PK_NAME_ELEM(NOTE_, FORK), 176 PK_NAME_ELEM(NOTE_, EXEC), 177 PK_NAME_ELEM(NOTE_, TRACK), 178 PK_NAME_ELEM(NOTE_, TRACKERR), 179 PK_NAME_ELEM(NOTE_, CHILD), 180 PK_FLAG_LAST_ELEM(), 181 }; 182 183 static const struct pk_elem timer_filter_names[] = { 184 PK_NAME_ELEM(NOTE_, SECONDS), 185 PK_NAME_ELEM(NOTE_, MSECONDS), 186 PK_NAME_ELEM(NOTE_, USECONDS), 187 PK_NAME_ELEM(NOTE_, NSECONDS), 188 PK_NAME_ELEM(NOTE_, ABSTIME), 189 PK_FLAG_LAST_ELEM(), 190 }; 191 192 #define FILT_ELEM(name) [-EVFILT_##name] = "EVFILT_"#name 193 static const struct pk_elem *const filter_pk_names[] = { 194 [0] = NULL, 195 [-EVFILT_READ] = rw_filter_names, 196 [-EVFILT_WRITE] = rw_filter_names, 197 [-EVFILT_AIO] = rw_filter_names, 198 [-EVFILT_VNODE] = vnode_filter_names, 199 [-EVFILT_PROC] = proc_filter_names, 200 [-EVFILT_SIGNAL] = NULL, 201 [-EVFILT_TIMER] = timer_filter_names, 202 [-EVFILT_PROCDESC] = proc_filter_names, 203 [-EVFILT_FS] = NULL, 204 [-EVFILT_LIO] = rw_filter_names, 205 [-EVFILT_USER] = user_filter_names, 206 [-EVFILT_SENDFILE] = NULL, 207 [-EVFILT_EMPTY] = NULL, 208 }; 209 210 static char * 211 procstat_kqueue_fflags(int filter, unsigned fflags) 212 { 213 const struct pk_elem *names; 214 215 names = NULL; 216 if (filter < 0 && -filter < (int)nitems(filter_pk_names)) 217 names = filter_pk_names[-filter]; 218 if (names == NULL) 219 return (strdup("-")); 220 return (procstat_kqueue_flags(names, fflags, true)); 221 } 222 223 static const char * 224 procstat_kqueue_get_filter_name(int filter) 225 { 226 filter = -filter; 227 if (filter < 0 || filter >= (int)nitems(filter_names)) 228 filter = 0; 229 return (filter_names[filter]); 230 } 231 232 static void 233 procstat_kqueue(struct procstat *procstat, struct kinfo_proc *kipp, int fd, 234 bool verbose) 235 { 236 struct kinfo_knote *kni, *knis; 237 char *flags, *fflags, *status; 238 unsigned int count, i, j; 239 char errbuf[_POSIX2_LINE_MAX]; 240 241 errbuf[0] = '\0'; 242 knis = procstat_get_kqueue_info(procstat, kipp, fd, &count, errbuf); 243 if (knis == NULL) { 244 warnx("%s\n", errbuf); 245 return; 246 } 247 248 for (i = 0; i < count; i++) { 249 kni = &knis[i]; 250 flags = procstat_kqueue_flags(ev_flags_names, 251 kni->knt_event.flags, false); 252 fflags = procstat_kqueue_fflags(kni->knt_event.filter, 253 kni->knt_event.fflags); 254 status = procstat_kqueue_flags(kn_status_names, 255 kni->knt_status, false); 256 xo_open_instance(kq); 257 xo_emit("{dk:process_id/%7d} ", kipp->ki_pid); 258 xo_emit("{:kqueue_fd/%10d} ", fd); 259 xo_emit("{:filter/%8s} ", procstat_kqueue_get_filter_name( 260 kni->knt_event.filter)); 261 xo_emit("{:ident/%10d} ", kni->knt_event.ident); 262 xo_emit("{:flags/%10s} ", flags); 263 xo_emit("{:fflags/%10s} ", fflags); 264 xo_emit("{:data/%#10jx} ", (uintmax_t)kni->knt_event.data); 265 xo_emit("{:udata/%10p} ", (uintmax_t)kni->knt_event.udata); 266 if (verbose) { 267 for (j = 0; j < nitems(kni->knt_event.ext); j++) { 268 xo_emit("{:ext%u/%#10jx} ", j, 269 (uintmax_t)kni->knt_event.ext[j]); 270 } 271 } 272 xo_emit("{:status/%10s}\n", status); 273 free(flags); 274 free(fflags); 275 free(status); 276 xo_close_instance(kq); 277 } 278 279 procstat_freekqinfo(procstat, knis); 280 } 281 282 void 283 procstat_kqueues(struct procstat *procstat, struct kinfo_proc *kipp) 284 { 285 struct filestat_list *fl; 286 struct filestat *f; 287 bool verbose; 288 289 verbose = (procstat_opts & PS_OPT_VERBOSE) != 0; 290 if ((procstat_opts & PS_OPT_NOHEADER) == 0) { 291 if (verbose) { 292 xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s " 293 "%10s %10s %10s %10s %10s}\n", 294 "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS", 295 "DATA", "UDATA", "EXT0", "EXT1","EXT2","EXT3", 296 "STATUS"); 297 } else { 298 xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s " 299 "%10s}\n", 300 "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS", 301 "DATA", "UDATA", "STATUS"); 302 } 303 } 304 305 xo_emit("{ek:process_id/%d}", kipp->ki_pid); 306 307 fl = procstat_getfiles(procstat, kipp, 0); 308 if (fl == NULL) 309 return; 310 xo_open_list(kqs); 311 STAILQ_FOREACH(f, fl, next) { 312 if (f->fs_type != PS_FST_TYPE_KQUEUE) 313 continue; 314 xo_emit("{ek:kqueue/%d}", f->fs_fd); 315 xo_open_list(kq); 316 procstat_kqueue(procstat, kipp, f->fs_fd, verbose); 317 xo_close_list(kq); 318 } 319 xo_close_list(kqs); 320 procstat_freefiles(procstat, fl); 321 } 322