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 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 * 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 * 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 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 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