From nobody Mon Apr 07 01:29:01 2025 X-Original-To: dev-commits-src-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4ZWBSZ15Ngz5sNJb; Mon, 07 Apr 2025 01:29:02 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R10" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4ZWBSY40cFz3wJ1; Mon, 07 Apr 2025 01:29:01 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1743989341; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=4cSzV15Oeu+I4nixbAHeVkG+Z2Z3HuOh6iGT/IA1XGk=; b=YWQCsN20UvZwnVT/J5CKh0Yt236QX/RoFCCix6SfpjFh8IF2ecrBDl+XJRUIrlGL7iU4pp S15hxw2lhcluxFeP0qBB4G+t91nGQT+BKttNTYR9tPi9UnulME7fGPQcWGDaRNIW/YTJoa hOaWFJTlcZbExba3FmQ6MxDG+fv9Osg1NWG+dZhRkmJjr23aQ54uo04UISNFH9FlMMKzy9 da7GeZwOFXAg9TrubY5+FB/vXMMbqvwtG8XNlf8iKsqk80ecysN9gCQflijFdNxP84uhja a+MFeupD/T+qBLf/eQj1GJN97repJ05lnZ/JhbjEk7KMBw9hxbeaIdC71Is+Iw== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1743989341; a=rsa-sha256; cv=none; b=ViU5Ft8aWTKRUJgg0lEYzDkrIi156+JE5jPpLNy4H/4yHPznzsrKKoI+m/N0KMuasCL50K CMFpKYuQpJSKgf02hRsVaYJVBLFtUuTrb92ex/Mlib716Dbcd2EoeI+z9kYNFxptqrDZ1x ZFqKGGEbTEDU2L3KPdYrmvGVtcJLGgszFkzoCevocyogLmXQ753nUoRi5+8iS+an0LVPn+ 0j3Qlk81ykjtAQCJbSXfaaB8lTi/LoIY5jAQRrc9ha2jdErEpPWh6syjB+HTrb8JvBWu/m lwQ7t7qaOc3mdhuSMqTPOVTM4kv+pRzn/oHFup8vBTlrh/dgB+vYx6lJLlkQNw== ARC-Authentication-Results: i=1; mx1.freebsd.org; none ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1743989341; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=4cSzV15Oeu+I4nixbAHeVkG+Z2Z3HuOh6iGT/IA1XGk=; b=PqaS6PVCrG71O9oXRRnF8KHd6lDO/5IxGR9CfPj33ZWnbASMp0laOUMGcM0uogBUEorStk 316ULpSyrhsxtgy9tPurRB3zTRGgp3AZzLo4rRrFYnVQBwEkGZFRZ/V1NcOAUA/rFIKkh6 EGwXJto72b6VGx8Siv0jSslkFBCGTwuFp1ckjqDejs/JJngCcnwp6ciYgiK7r3+Ov6yOR0 cNKOPFLEn6JRhENZbuqG5Qy9IR8sOQ++jH6IwaQ5b8pRLfvOHn0xx7zjFlsSEs9Rahhll7 5rDmuNK+R16RerPk6+K0i+6Y6mIw9nRwJVc8Ag3MwJROZ4Yqs7G+adcUEaAn9Q== Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 4ZWBSY1P37z974; Mon, 07 Apr 2025 01:29:01 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.18.1/8.18.1) with ESMTP id 5371T1OO062943; Mon, 7 Apr 2025 01:29:01 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.18.1/8.18.1/Submit) id 5371T12m062940; Mon, 7 Apr 2025 01:29:01 GMT (envelope-from git) Date: Mon, 7 Apr 2025 01:29:01 GMT Message-Id: <202504070129.5371T12m062940@gitrepo.freebsd.org> To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-branches@FreeBSD.org From: Konstantin Belousov Subject: git: a15cae4c746a - stable/14 - procstat(1): dump kqueues List-Id: Commit messages for all branches of the src repository List-Archive: https://lists.freebsd.org/archives/dev-commits-src-all List-Help: List-Post: List-Subscribe: List-Unsubscribe: X-BeenThere: dev-commits-src-all@freebsd.org Sender: owner-dev-commits-src-all@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: kib X-Git-Repository: src X-Git-Refname: refs/heads/stable/14 X-Git-Reftype: branch X-Git-Commit: a15cae4c746ac076c5e273d8d31b16f25632a963 Auto-Submitted: auto-generated The branch stable/14 has been updated by kib: URL: https://cgit.FreeBSD.org/src/commit/?id=a15cae4c746ac076c5e273d8d31b16f25632a963 commit a15cae4c746ac076c5e273d8d31b16f25632a963 Author: Konstantin Belousov AuthorDate: 2025-02-26 00:29:49 +0000 Commit: Konstantin Belousov CommitDate: 2025-04-07 01:28:21 +0000 procstat(1): dump kqueues (cherry picked from commit 28f4cf9217c27edea42c5c024c9e71816890bb3c) --- usr.bin/procstat/Makefile | 1 + usr.bin/procstat/procstat.c | 20 +++ usr.bin/procstat/procstat.h | 1 + usr.bin/procstat/procstat_kqueue.c | 319 +++++++++++++++++++++++++++++++++++++ 4 files changed, 341 insertions(+) diff --git a/usr.bin/procstat/Makefile b/usr.bin/procstat/Makefile index cfd8578c0dbc..a095e4e25ffd 100644 --- a/usr.bin/procstat/Makefile +++ b/usr.bin/procstat/Makefile @@ -12,6 +12,7 @@ SRCS= procstat.c \ procstat_cred.c \ procstat_cs.c \ procstat_files.c \ + procstat_kqueue.c \ procstat_kstack.c \ procstat_penv.c \ procstat_ptlwpinfo.c \ diff --git a/usr.bin/procstat/procstat.c b/usr.bin/procstat/procstat.c index 120a377bc756..cc9ddd473782 100644 --- a/usr.bin/procstat/procstat.c +++ b/usr.bin/procstat/procstat.c @@ -66,6 +66,7 @@ static void cmdopt_signals(int argc, char * const argv[]); static void cmdopt_rusage(int argc, char * const argv[]); static void cmdopt_files(int argc, char * const argv[]); static void cmdopt_cpuset(int argc, char * const argv[]); +static void cmdopt_kqueue(int argc, char * const argv[]); static const char *progname; @@ -104,6 +105,8 @@ static const struct procstat_cmd cmd_table[] = { PS_CMP_PLURAL }, { "file", "files", "[-C]", &procstat_files, &cmdopt_files, PS_CMP_PLURAL }, + { "kqueue", "kqueues", NULL, &procstat_kqueues, &cmdopt_kqueue, + PS_CMP_PLURAL }, { "kstack", "kstack", "[-v]", &procstat_kstack, &cmdopt_verbose, PS_CMP_NORMAL }, { "pargs", "args", NULL, &procstat_pargs, &cmdopt_none, @@ -632,3 +635,20 @@ cmdopt_cpuset(int argc, char * const argv[]) procstat_opts |= PS_OPT_PERTHREAD; cmdopt_none(argc, argv); } + +void +cmdopt_kqueue(int argc, char * const argv[]) +{ + int ch; + + while ((ch = getopt(argc, argv, "v")) != -1) { + switch (ch) { + case 'v': + procstat_opts |= PS_OPT_VERBOSE; + break; + case '?': + default: + usage(NULL); + } + } +} diff --git a/usr.bin/procstat/procstat.h b/usr.bin/procstat/procstat.h index f106fac79127..e075065315f8 100644 --- a/usr.bin/procstat/procstat.h +++ b/usr.bin/procstat/procstat.h @@ -64,6 +64,7 @@ void procstat_cred(struct procstat *prstat, struct kinfo_proc *kipp); void procstat_cs(struct procstat *prstat, struct kinfo_proc *kipp); void procstat_env(struct procstat *prstat, struct kinfo_proc *kipp); void procstat_files(struct procstat *prstat, struct kinfo_proc *kipp); +void procstat_kqueues(struct procstat *prstat, struct kinfo_proc *kipp); void procstat_kstack(struct procstat *prstat, struct kinfo_proc *kipp); void procstat_rlimitusage(struct procstat *procstat, struct kinfo_proc *kipp); diff --git a/usr.bin/procstat/procstat_kqueue.c b/usr.bin/procstat/procstat_kqueue.c new file mode 100644 index 000000000000..ce9d2cb42fe2 --- /dev/null +++ b/usr.bin/procstat/procstat_kqueue.c @@ -0,0 +1,319 @@ +/*- + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2025 The FreeBSD Foundation + * + * This software was developed by Konstantin Belousov + * under sponsorship from the FreeBSD Foundation. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "procstat.h" + +static const char kqs[] = "kqueues"; +static const char kq[] = "kqueue"; + +#define FILT_ELEM(name) [-EVFILT_##name] = #name, +static const char *const filter_names[] = { + [0] = "invalid", + FILT_ELEM(READ) + FILT_ELEM(WRITE) + FILT_ELEM(AIO) + FILT_ELEM(VNODE) + FILT_ELEM(PROC) + FILT_ELEM(SIGNAL) + FILT_ELEM(TIMER) + FILT_ELEM(PROCDESC) + FILT_ELEM(FS) + FILT_ELEM(LIO) + FILT_ELEM(USER) + FILT_ELEM(SENDFILE) + FILT_ELEM(EMPTY) +}; +#undef FILT_ELEM + +#define PK_FLAG_ELEM(fname, str) { .flag = fname, .dispstr = str } +#define PK_NAME_ELEM(prefix, fname) { .flag = prefix##fname, .dispstr = #fname } +#define PK_FLAG_LAST_ELEM() { .flag = -1, .dispstr = NULL } +struct pk_elem { + unsigned int flag; + const char *dispstr; +}; + +static const struct pk_elem kn_status_names[] = { + PK_FLAG_ELEM(KNOTE_STATUS_ACTIVE, "A"), + PK_FLAG_ELEM(KNOTE_STATUS_QUEUED, "Q"), + PK_FLAG_ELEM(KNOTE_STATUS_DISABLED, "D"), + PK_FLAG_ELEM(KNOTE_STATUS_DETACHED, "d"), + PK_FLAG_ELEM(KNOTE_STATUS_KQUEUE, "K"), + PK_FLAG_LAST_ELEM(), +}; + +static const struct pk_elem ev_flags_names[] = { + PK_FLAG_ELEM(EV_ONESHOT, "O"), + PK_FLAG_ELEM(EV_CLEAR, "C"), + PK_FLAG_ELEM(EV_RECEIPT, "R"), + PK_FLAG_ELEM(EV_DISPATCH, "D"), + PK_FLAG_ELEM(EV_DROP, "d"), + PK_FLAG_ELEM(EV_FLAG1, "1"), + PK_FLAG_ELEM(EV_FLAG2, "2"), + PK_FLAG_LAST_ELEM(), +}; + +static char * +procstat_kqueue_flags(const struct pk_elem *names, unsigned flags, bool commas) +{ + char *res; + const struct pk_elem *pl; + size_t len; + int i; + bool first; + + first = true; + len = 0; + for (i = 0;; i++) { + pl = &names[i]; + if (pl->flag == (unsigned)-1) + break; + if ((flags & pl->flag) != 0) { + if (first) + first = false; + else if (commas) + len += sizeof(","); + len += strlen(pl->dispstr); + } + } + len++; + + res = malloc(len); + first = true; + res[0] = '\0'; + for (i = 0;; i++) { + pl = &names[i]; + if (pl->flag == (unsigned)-1) + break; + if ((flags & pl->flag) != 0) { + if (first) + first = false; + else if (commas) + strlcat(res, ",", len); + strlcat(res, pl->dispstr, len); + } + } + + if (strlen(res) == 0) + return (strdup("-")); + return (res); +} + +static const struct pk_elem rw_filter_names[] = { + PK_NAME_ELEM(NOTE_, LOWAT), + PK_NAME_ELEM(NOTE_, FILE_POLL), + PK_FLAG_LAST_ELEM(), +}; + +static const struct pk_elem user_filter_names[] = { + PK_NAME_ELEM(NOTE_, FFAND), + PK_NAME_ELEM(NOTE_, FFOR), + PK_NAME_ELEM(NOTE_, TRIGGER), + PK_FLAG_LAST_ELEM(), +}; + +static const struct pk_elem vnode_filter_names[] = { + PK_NAME_ELEM(NOTE_, DELETE), + PK_NAME_ELEM(NOTE_, WRITE), + PK_NAME_ELEM(NOTE_, EXTEND), + PK_NAME_ELEM(NOTE_, ATTRIB), + PK_NAME_ELEM(NOTE_, LINK), + PK_NAME_ELEM(NOTE_, RENAME), + PK_NAME_ELEM(NOTE_, REVOKE), + PK_NAME_ELEM(NOTE_, OPEN), + PK_NAME_ELEM(NOTE_, CLOSE), + PK_NAME_ELEM(NOTE_, CLOSE_WRITE), + PK_NAME_ELEM(NOTE_, READ), + PK_FLAG_LAST_ELEM(), +}; + +static const struct pk_elem proc_filter_names[] = { + PK_NAME_ELEM(NOTE_, EXIT), + PK_NAME_ELEM(NOTE_, FORK), + PK_NAME_ELEM(NOTE_, EXEC), + PK_NAME_ELEM(NOTE_, TRACK), + PK_NAME_ELEM(NOTE_, TRACKERR), + PK_NAME_ELEM(NOTE_, CHILD), + PK_FLAG_LAST_ELEM(), +}; + +static const struct pk_elem timer_filter_names[] = { + PK_NAME_ELEM(NOTE_, SECONDS), + PK_NAME_ELEM(NOTE_, MSECONDS), + PK_NAME_ELEM(NOTE_, USECONDS), + PK_NAME_ELEM(NOTE_, NSECONDS), + PK_NAME_ELEM(NOTE_, ABSTIME), + PK_FLAG_LAST_ELEM(), +}; + +#define FILT_ELEM(name) [-EVFILT_##name] = "EVFILT_"#name +static const struct pk_elem *const filter_pk_names[] = { + [0] = NULL, + [-EVFILT_READ] = rw_filter_names, + [-EVFILT_WRITE] = rw_filter_names, + [-EVFILT_AIO] = rw_filter_names, + [-EVFILT_VNODE] = vnode_filter_names, + [-EVFILT_PROC] = proc_filter_names, + [-EVFILT_SIGNAL] = NULL, + [-EVFILT_TIMER] = timer_filter_names, + [-EVFILT_PROCDESC] = proc_filter_names, + [-EVFILT_FS] = NULL, + [-EVFILT_LIO] = rw_filter_names, + [-EVFILT_USER] = user_filter_names, + [-EVFILT_SENDFILE] = NULL, + [-EVFILT_EMPTY] = NULL, +}; + +static char * +procstat_kqueue_fflags(int filter, unsigned fflags) +{ + const struct pk_elem *names; + + names = NULL; + if (filter < 0 && -filter < (int)nitems(filter_pk_names)) + names = filter_pk_names[-filter]; + if (names == NULL) + return (strdup("-")); + return (procstat_kqueue_flags(names, fflags, true)); +} + +static const char * +procstat_kqueue_get_filter_name(int filter) +{ + filter = -filter; + if (filter < 0 || filter >= (int)nitems(filter_names)) + filter = 0; + return (filter_names[filter]); +} + +static void +procstat_kqueue(struct procstat *procstat, struct kinfo_proc *kipp, int fd, + bool verbose) +{ + struct kinfo_knote *kni, *knis; + char *flags, *fflags, *status; + unsigned int count, i, j; + char errbuf[_POSIX2_LINE_MAX]; + + errbuf[0] = '\0'; + knis = procstat_get_kqueue_info(procstat, kipp, fd, &count, errbuf); + if (knis == NULL) { + warnx("%s\n", errbuf); + return; + } + + for (i = 0; i < count; i++) { + kni = &knis[i]; + flags = procstat_kqueue_flags(ev_flags_names, + kni->knt_event.flags, false); + fflags = procstat_kqueue_fflags(kni->knt_event.filter, + kni->knt_event.fflags); + status = procstat_kqueue_flags(kn_status_names, + kni->knt_status, false); + xo_open_instance(kq); + xo_emit("{dk:process_id/%7d} ", kipp->ki_pid); + xo_emit("{:kqueue_fd/%10d} ", fd); + xo_emit("{:filter/%8s} ", procstat_kqueue_get_filter_name( + kni->knt_event.filter)); + xo_emit("{:ident/%10d} ", kni->knt_event.ident); + xo_emit("{:flags/%10s} ", flags); + xo_emit("{:fflags/%10s} ", fflags); + xo_emit("{:data/%#10jx} ", (uintmax_t)kni->knt_event.data); + xo_emit("{:udata/%10p} ", (uintmax_t)kni->knt_event.udata); + if (verbose) { + for (j = 0; j < nitems(kni->knt_event.ext); j++) { + xo_emit("{:ext%u/%#10jx} ", j, + (uintmax_t)kni->knt_event.ext[j]); + } + } + xo_emit("{:status/%10s}\n", status); + free(flags); + free(fflags); + free(status); + xo_close_instance(kq); + } + + procstat_freekqinfo(procstat, knis); +} + +void +procstat_kqueues(struct procstat *procstat, struct kinfo_proc *kipp) +{ + struct filestat_list *fl; + struct filestat *f; + bool verbose; + + verbose = (procstat_opts & PS_OPT_VERBOSE) != 0; + if ((procstat_opts & PS_OPT_NOHEADER) == 0) { + if (verbose) { + xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s " + "%10s %10s %10s %10s %10s}\n", + "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS", + "DATA", "UDATA", "EXT0", "EXT1","EXT2","EXT3", + "STATUS"); + } else { + xo_emit("{T:/%7s %10s %8s %10s %10s %10s %10s %10s " + "%10s}\n", + "PID", "KQFD", "FILTER", "IDENT", "FLAGS", "FFLAGS", + "DATA", "UDATA", "STATUS"); + } + } + + xo_emit("{ek:process_id/%d}", kipp->ki_pid); + + fl = procstat_getfiles(procstat, kipp, 0); + if (fl == NULL) + return; + xo_open_list(kqs); + STAILQ_FOREACH(f, fl, next) { + if (f->fs_type != PS_FST_TYPE_KQUEUE) + continue; + xo_emit("{ek:kqueue/%d}", f->fs_fd); + xo_open_list(kq); + procstat_kqueue(procstat, kipp, f->fs_fd, verbose); + xo_close_list(kq); + } + xo_close_list(kqs); + procstat_freefiles(procstat, fl); +}