1994-05-27 12:33:43 +00:00
|
|
|
/*-
|
2017-11-20 19:49:47 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
*
|
1994-05-27 12:33:43 +00:00
|
|
|
* Copyright (c) 1988, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* 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.
|
2017-02-28 23:42:47 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-27 12:33:43 +00:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef lint
|
1997-07-16 06:49:49 +00:00
|
|
|
static const char copyright[] =
|
1994-05-27 12:33:43 +00:00
|
|
|
"@(#) Copyright (c) 1988, 1993\n\
|
|
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#ifndef lint
|
1997-07-16 06:49:49 +00:00
|
|
|
#if 0
|
1994-05-27 12:33:43 +00:00
|
|
|
static char sccsid[] = "@(#)kdump.c 8.1 (Berkeley) 6/6/93";
|
1997-07-16 06:49:49 +00:00
|
|
|
#endif
|
1994-05-27 12:33:43 +00:00
|
|
|
#endif /* not lint */
|
2002-06-30 05:25:07 +00:00
|
|
|
#include <sys/cdefs.h>
|
2016-10-01 22:08:07 +00:00
|
|
|
#define _WANT_KERNEL_ERRNO
|
2017-11-25 04:49:12 +00:00
|
|
|
#ifdef __LP64__
|
|
|
|
#define _WANT_KEVENT32
|
|
|
|
#endif
|
|
|
|
#define _WANT_FREEBSD11_KEVENT
|
2022-05-11 07:40:39 +00:00
|
|
|
#define _WANT_FREEBSD_BITSET
|
1994-05-27 12:33:43 +00:00
|
|
|
#include <sys/param.h>
|
2014-03-16 11:04:44 +00:00
|
|
|
#include <sys/capsicum.h>
|
2022-05-11 07:40:39 +00:00
|
|
|
#include <sys/_bitset.h>
|
|
|
|
#include <sys/bitset.h>
|
1994-05-27 12:33:43 +00:00
|
|
|
#include <sys/errno.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/uio.h>
|
2017-11-25 04:49:12 +00:00
|
|
|
#include <sys/event.h>
|
1994-05-27 12:33:43 +00:00
|
|
|
#include <sys/ktrace.h>
|
2020-02-19 14:32:55 +00:00
|
|
|
#include <sys/mman.h>
|
1994-05-27 12:33:43 +00:00
|
|
|
#include <sys/ioctl.h>
|
2007-01-04 04:46:59 +00:00
|
|
|
#include <sys/socket.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#include <sys/stat.h>
|
2011-02-25 22:07:23 +00:00
|
|
|
#include <sys/sysent.h>
|
2014-10-13 16:37:06 +00:00
|
|
|
#include <sys/umtx.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#include <sys/un.h>
|
2011-02-25 22:07:23 +00:00
|
|
|
#include <sys/queue.h>
|
2013-09-12 18:08:25 +00:00
|
|
|
#include <sys/wait.h>
|
2017-09-21 14:41:41 +00:00
|
|
|
#ifdef WITH_CASPER
|
2015-07-02 21:58:10 +00:00
|
|
|
#include <sys/nv.h>
|
|
|
|
#endif
|
2009-03-20 18:29:52 +00:00
|
|
|
#include <arpa/inet.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#include <netinet/in.h>
|
2009-03-20 18:29:52 +00:00
|
|
|
#include <ctype.h>
|
2016-10-07 17:56:57 +00:00
|
|
|
#include <capsicum_helpers.h>
|
1997-07-16 06:49:49 +00:00
|
|
|
#include <err.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#include <grp.h>
|
|
|
|
#include <inttypes.h>
|
1997-07-16 06:49:49 +00:00
|
|
|
#include <locale.h>
|
2013-06-07 08:06:48 +00:00
|
|
|
#include <netdb.h>
|
2013-05-28 21:25:28 +00:00
|
|
|
#include <nl_types.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#include <pwd.h>
|
2016-10-01 22:01:41 +00:00
|
|
|
#include <stddef.h>
|
1994-05-27 12:33:43 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2015-12-15 00:05:07 +00:00
|
|
|
#include <sysdecode.h>
|
2008-02-23 01:01:49 +00:00
|
|
|
#include <time.h>
|
1997-07-16 06:49:49 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <vis.h>
|
1994-05-27 12:33:43 +00:00
|
|
|
#include "ktrace.h"
|
2022-06-22 11:01:36 +00:00
|
|
|
#include "kdump.h"
|
1994-05-27 12:33:43 +00:00
|
|
|
|
2017-09-21 14:41:41 +00:00
|
|
|
#ifdef WITH_CASPER
|
2016-02-25 18:23:40 +00:00
|
|
|
#include <libcasper.h>
|
|
|
|
|
|
|
|
#include <casper/cap_grp.h>
|
|
|
|
#include <casper/cap_pwd.h>
|
|
|
|
#endif
|
|
|
|
|
2011-02-25 22:07:23 +00:00
|
|
|
int fetchprocinfo(struct ktr_header *, u_int *);
|
2018-08-07 00:10:58 +00:00
|
|
|
u_int findabi(struct ktr_header *);
|
2002-07-28 16:05:07 +00:00
|
|
|
int fread_tail(void *, int, int);
|
2018-08-07 00:10:58 +00:00
|
|
|
void dumpheader(struct ktr_header *, u_int);
|
2022-07-16 09:46:12 +00:00
|
|
|
void dumptimeval(struct ktr_header_v0 *kth);
|
|
|
|
void dumptimespec(struct ktr_header *kth);
|
2011-02-25 22:07:23 +00:00
|
|
|
void ktrsyscall(struct ktr_syscall *, u_int);
|
|
|
|
void ktrsysret(struct ktr_sysret *, u_int);
|
2002-07-28 16:05:07 +00:00
|
|
|
void ktrnamei(char *, int);
|
2003-06-03 01:44:43 +00:00
|
|
|
void hexdump(char *, int, int);
|
|
|
|
void visdump(char *, int, int);
|
2002-07-28 16:05:07 +00:00
|
|
|
void ktrgenio(struct ktr_genio *, int);
|
2011-03-01 16:42:28 +00:00
|
|
|
void ktrpsig(struct ktr_psig *);
|
2002-07-28 16:05:07 +00:00
|
|
|
void ktrcsw(struct ktr_csw *);
|
2012-04-20 15:32:36 +00:00
|
|
|
void ktrcsw_old(struct ktr_csw_old *);
|
2014-10-13 16:17:42 +00:00
|
|
|
void ktruser(int, void *);
|
Change the cap_rights_t type from uint64_t to a structure that we can extend
in the future in a backward compatible (API and ABI) way.
The cap_rights_t represents capability rights. We used to use one bit to
represent one right, but we are running out of spare bits. Currently the new
structure provides place for 114 rights (so 50 more than the previous
cap_rights_t), but it is possible to grow the structure to hold at least 285
rights, although we can make it even larger if 285 rights won't be enough.
The structure definition looks like this:
struct cap_rights {
uint64_t cr_rights[CAP_RIGHTS_VERSION + 2];
};
The initial CAP_RIGHTS_VERSION is 0.
The top two bits in the first element of the cr_rights[] array contain total
number of elements in the array - 2. This means if those two bits are equal to
0, we have 2 array elements.
The top two bits in all remaining array elements should be 0.
The next five bits in all array elements contain array index. Only one bit is
used and bit position in this five-bits range defines array index. This means
there can be at most five array elements in the future.
To define new right the CAPRIGHT() macro must be used. The macro takes two
arguments - an array index and a bit to set, eg.
#define CAP_PDKILL CAPRIGHT(1, 0x0000000000000800ULL)
We still support aliases that combine few rights, but the rights have to belong
to the same array element, eg:
#define CAP_LOOKUP CAPRIGHT(0, 0x0000000000000400ULL)
#define CAP_FCHMOD CAPRIGHT(0, 0x0000000000002000ULL)
#define CAP_FCHMODAT (CAP_FCHMOD | CAP_LOOKUP)
There is new API to manage the new cap_rights_t structure:
cap_rights_t *cap_rights_init(cap_rights_t *rights, ...);
void cap_rights_set(cap_rights_t *rights, ...);
void cap_rights_clear(cap_rights_t *rights, ...);
bool cap_rights_is_set(const cap_rights_t *rights, ...);
bool cap_rights_is_valid(const cap_rights_t *rights);
void cap_rights_merge(cap_rights_t *dst, const cap_rights_t *src);
void cap_rights_remove(cap_rights_t *dst, const cap_rights_t *src);
bool cap_rights_contains(const cap_rights_t *big, const cap_rights_t *little);
Capability rights to the cap_rights_init(), cap_rights_set(),
cap_rights_clear() and cap_rights_is_set() functions are provided by
separating them with commas, eg:
cap_rights_t rights;
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FSTAT);
There is no need to terminate the list of rights, as those functions are
actually macros that take care of the termination, eg:
#define cap_rights_set(rights, ...) \
__cap_rights_set((rights), __VA_ARGS__, 0ULL)
void __cap_rights_set(cap_rights_t *rights, ...);
Thanks to using one bit as an array index we can assert in those functions that
there are no two rights belonging to different array elements provided
together. For example this is illegal and will be detected, because CAP_LOOKUP
belongs to element 0 and CAP_PDKILL to element 1:
cap_rights_init(&rights, CAP_LOOKUP | CAP_PDKILL);
Providing several rights that belongs to the same array's element this way is
correct, but is not advised. It should only be used for aliases definition.
This commit also breaks compatibility with some existing Capsicum system calls,
but I see no other way to do that. This should be fine as Capsicum is still
experimental and this change is not going to 9.x.
Sponsored by: The FreeBSD Foundation
2013-09-05 00:09:56 +00:00
|
|
|
void ktrcaprights(cap_rights_t *);
|
2016-07-13 14:37:58 +00:00
|
|
|
void ktritimerval(struct itimerval *it);
|
2008-02-23 01:01:49 +00:00
|
|
|
void ktrsockaddr(struct sockaddr *);
|
|
|
|
void ktrstat(struct stat *);
|
|
|
|
void ktrstruct(char *, size_t);
|
2011-10-11 20:37:10 +00:00
|
|
|
void ktrcapfail(struct ktr_cap_fail *);
|
2012-04-05 17:13:14 +00:00
|
|
|
void ktrfault(struct ktr_fault *);
|
|
|
|
void ktrfaultend(struct ktr_faultend *);
|
2017-11-25 04:49:12 +00:00
|
|
|
void ktrkevent(struct kevent *);
|
|
|
|
void ktrstructarray(struct ktr_struct_array *, size_t);
|
2022-05-11 07:40:39 +00:00
|
|
|
void ktrbitset(char *, struct bitset *, size_t);
|
2022-06-22 11:03:56 +00:00
|
|
|
void ktrsyscall_freebsd(struct ktr_syscall *ktr, register_t **resip,
|
|
|
|
int *resnarg, char *resc, u_int sv_flags);
|
2002-07-28 16:05:07 +00:00
|
|
|
void usage(void);
|
|
|
|
|
2014-03-25 23:37:57 +00:00
|
|
|
#define TIMESTAMP_NONE 0x0
|
|
|
|
#define TIMESTAMP_ABSOLUTE 0x1
|
|
|
|
#define TIMESTAMP_ELAPSED 0x2
|
|
|
|
#define TIMESTAMP_RELATIVE 0x4
|
|
|
|
|
2022-06-22 11:01:36 +00:00
|
|
|
bool decimal, fancy = true, resolv;
|
2022-07-16 09:46:12 +00:00
|
|
|
static bool abiflag, suppressdata, syscallno, tail, threads, cpuflag;
|
2018-08-18 20:23:53 +00:00
|
|
|
static int timestamp, maxdata;
|
2014-10-13 16:17:42 +00:00
|
|
|
static const char *tracefile = DEF_TRACEFILE;
|
|
|
|
static struct ktr_header ktr_header;
|
2022-07-16 09:46:12 +00:00
|
|
|
static short version;
|
1994-05-27 12:33:43 +00:00
|
|
|
|
2008-02-23 01:01:49 +00:00
|
|
|
#define TIME_FORMAT "%b %e %T %Y"
|
1994-05-27 12:33:43 +00:00
|
|
|
#define eqs(s1, s2) (strcmp((s1), (s2)) == 0)
|
|
|
|
|
2011-02-25 22:07:23 +00:00
|
|
|
struct proc_info
|
|
|
|
{
|
|
|
|
TAILQ_ENTRY(proc_info) info;
|
|
|
|
u_int sv_flags;
|
|
|
|
pid_t pid;
|
|
|
|
};
|
|
|
|
|
2014-10-13 16:17:42 +00:00
|
|
|
static TAILQ_HEAD(trace_procs, proc_info) trace_procs;
|
2011-02-25 22:07:23 +00:00
|
|
|
|
2017-09-21 14:41:41 +00:00
|
|
|
#ifdef WITH_CASPER
|
2013-12-15 23:09:05 +00:00
|
|
|
static cap_channel_t *cappwd, *capgrp;
|
2013-07-18 21:56:10 +00:00
|
|
|
|
2013-12-15 23:09:05 +00:00
|
|
|
static int
|
|
|
|
cappwdgrp_setup(cap_channel_t **cappwdp, cap_channel_t **capgrpp)
|
|
|
|
{
|
|
|
|
cap_channel_t *capcas, *cappwdloc, *capgrploc;
|
|
|
|
const char *cmds[1], *fields[1];
|
|
|
|
|
|
|
|
capcas = cap_init();
|
|
|
|
if (capcas == NULL) {
|
2016-02-25 18:23:40 +00:00
|
|
|
err(1, "unable to create casper process");
|
|
|
|
exit(1);
|
2013-12-15 23:09:05 +00:00
|
|
|
}
|
|
|
|
cappwdloc = cap_service_open(capcas, "system.pwd");
|
|
|
|
capgrploc = cap_service_open(capcas, "system.grp");
|
|
|
|
/* Casper capability no longer needed. */
|
|
|
|
cap_close(capcas);
|
|
|
|
if (cappwdloc == NULL || capgrploc == NULL) {
|
|
|
|
if (cappwdloc == NULL)
|
|
|
|
warn("unable to open system.pwd service");
|
|
|
|
if (capgrploc == NULL)
|
|
|
|
warn("unable to open system.grp service");
|
2013-12-19 00:51:48 +00:00
|
|
|
exit(1);
|
2013-12-15 23:09:05 +00:00
|
|
|
}
|
|
|
|
/* Limit system.pwd to only getpwuid() function and pw_name field. */
|
|
|
|
cmds[0] = "getpwuid";
|
2013-12-19 00:51:48 +00:00
|
|
|
if (cap_pwd_limit_cmds(cappwdloc, cmds, 1) < 0)
|
|
|
|
err(1, "unable to limit system.pwd service");
|
2013-12-15 23:09:05 +00:00
|
|
|
fields[0] = "pw_name";
|
2013-12-19 00:51:48 +00:00
|
|
|
if (cap_pwd_limit_fields(cappwdloc, fields, 1) < 0)
|
|
|
|
err(1, "unable to limit system.pwd service");
|
2013-12-15 23:09:05 +00:00
|
|
|
/* Limit system.grp to only getgrgid() function and gr_name field. */
|
|
|
|
cmds[0] = "getgrgid";
|
2013-12-19 00:51:48 +00:00
|
|
|
if (cap_grp_limit_cmds(capgrploc, cmds, 1) < 0)
|
|
|
|
err(1, "unable to limit system.grp service");
|
2013-12-15 23:09:05 +00:00
|
|
|
fields[0] = "gr_name";
|
2013-12-19 00:51:48 +00:00
|
|
|
if (cap_grp_limit_fields(capgrploc, fields, 1) < 0)
|
|
|
|
err(1, "unable to limit system.grp service");
|
2013-12-15 23:09:05 +00:00
|
|
|
|
|
|
|
*cappwdp = cappwdloc;
|
|
|
|
*capgrpp = capgrploc;
|
|
|
|
return (0);
|
|
|
|
}
|
2017-09-21 14:41:41 +00:00
|
|
|
#endif /* WITH_CASPER */
|
2013-12-15 23:09:05 +00:00
|
|
|
|
2022-06-22 11:01:36 +00:00
|
|
|
void
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(const char *(*decoder)(int), int value)
|
|
|
|
{
|
|
|
|
const char *str;
|
|
|
|
|
|
|
|
str = decoder(value);
|
|
|
|
if (str != NULL)
|
|
|
|
printf("%s", str);
|
|
|
|
else {
|
|
|
|
if (decimal)
|
|
|
|
printf("<invalid=%d>", value);
|
|
|
|
else
|
|
|
|
printf("<invalid=%#x>", value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Like print_integer_arg but unknown values are treated as valid. */
|
2022-06-22 11:01:36 +00:00
|
|
|
void
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg_valid(const char *(*decoder)(int), int value)
|
|
|
|
{
|
|
|
|
const char *str;
|
|
|
|
|
|
|
|
str = decoder(value);
|
|
|
|
if (str != NULL)
|
|
|
|
printf("%s", str);
|
|
|
|
else {
|
|
|
|
if (decimal)
|
|
|
|
printf("%d", value);
|
|
|
|
else
|
|
|
|
printf("%#x", value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-22 11:01:36 +00:00
|
|
|
bool
|
kdump/truss: decode new _umtx_op flags
In both cases, print the flag bits first followed by the command.
Output now looks something like this:
(ktrace)
_umtx_op(0x8605f7008,0xf<UMTX_OP_WAIT_UINT_PRIVATE>,0,0,0)
_umtx_op(0x9fffdce8,0x80000003<UMTX_OP__32BIT|UMTX_OP_WAKE>,0x1,0,0)
(truss)
_umtx_op(0x7fffffffda50,UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
_umtx_op(0x9fffdd08,UMTX_OP__32BIT|UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
Reviewed by: kib
Differential Revision: https://reviews.freebsd.org/D27325
2020-12-09 03:24:09 +00:00
|
|
|
print_mask_arg_part(bool (*decoder)(FILE *, int, int *), int value, int *rem)
|
|
|
|
{
|
|
|
|
|
|
|
|
printf("%#x<", value);
|
|
|
|
return (decoder(stdout, value, rem));
|
|
|
|
}
|
|
|
|
|
2022-06-22 11:01:36 +00:00
|
|
|
void
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(bool (*decoder)(FILE *, int, int *), int value)
|
|
|
|
{
|
|
|
|
bool invalid;
|
|
|
|
int rem;
|
|
|
|
|
kdump/truss: decode new _umtx_op flags
In both cases, print the flag bits first followed by the command.
Output now looks something like this:
(ktrace)
_umtx_op(0x8605f7008,0xf<UMTX_OP_WAIT_UINT_PRIVATE>,0,0,0)
_umtx_op(0x9fffdce8,0x80000003<UMTX_OP__32BIT|UMTX_OP_WAKE>,0x1,0,0)
(truss)
_umtx_op(0x7fffffffda50,UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
_umtx_op(0x9fffdd08,UMTX_OP__32BIT|UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
Reviewed by: kib
Differential Revision: https://reviews.freebsd.org/D27325
2020-12-09 03:24:09 +00:00
|
|
|
invalid = !print_mask_arg_part(decoder, value, &rem);
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
printf(">");
|
|
|
|
if (invalid)
|
|
|
|
printf("<invalid>%u", rem);
|
|
|
|
}
|
|
|
|
|
2022-06-22 11:01:36 +00:00
|
|
|
void
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg0(bool (*decoder)(FILE *, int, int *), int value)
|
|
|
|
{
|
|
|
|
bool invalid;
|
|
|
|
int rem;
|
|
|
|
|
|
|
|
if (value == 0) {
|
|
|
|
printf("0");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
printf("%#x<", value);
|
|
|
|
invalid = !decoder(stdout, value, &rem);
|
|
|
|
printf(">");
|
|
|
|
if (invalid)
|
|
|
|
printf("<invalid>%u", rem);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
decode_fileflags(fflags_t value)
|
|
|
|
{
|
|
|
|
bool invalid;
|
|
|
|
fflags_t rem;
|
|
|
|
|
|
|
|
if (value == 0) {
|
|
|
|
printf("0");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
printf("%#x<", value);
|
|
|
|
invalid = !sysdecode_fileflags(stdout, value, &rem);
|
|
|
|
printf(">");
|
|
|
|
if (invalid)
|
|
|
|
printf("<invalid>%u", rem);
|
|
|
|
}
|
|
|
|
|
2022-06-22 11:26:50 +00:00
|
|
|
void
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
decode_filemode(int value)
|
|
|
|
{
|
|
|
|
bool invalid;
|
|
|
|
int rem;
|
|
|
|
|
|
|
|
if (value == 0) {
|
|
|
|
printf("0");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
printf("%#o<", value);
|
|
|
|
invalid = !sysdecode_filemode(stdout, value, &rem);
|
|
|
|
printf(">");
|
|
|
|
if (invalid)
|
|
|
|
printf("<invalid>%u", rem);
|
|
|
|
}
|
|
|
|
|
2022-06-22 11:01:36 +00:00
|
|
|
void
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg32(bool (*decoder)(FILE *, uint32_t, uint32_t *), uint32_t value)
|
|
|
|
{
|
|
|
|
bool invalid;
|
|
|
|
uint32_t rem;
|
|
|
|
|
|
|
|
printf("%#x<", value);
|
|
|
|
invalid = !decoder(stdout, value, &rem);
|
|
|
|
printf(">");
|
|
|
|
if (invalid)
|
|
|
|
printf("<invalid>%u", rem);
|
|
|
|
}
|
|
|
|
|
2022-06-22 11:01:36 +00:00
|
|
|
void
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_argul(bool (*decoder)(FILE *, u_long, u_long *), u_long value)
|
|
|
|
{
|
|
|
|
bool invalid;
|
|
|
|
u_long rem;
|
|
|
|
|
|
|
|
if (value == 0) {
|
|
|
|
printf("0");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
printf("%#lx<", value);
|
|
|
|
invalid = !decoder(stdout, value, &rem);
|
|
|
|
printf(">");
|
|
|
|
if (invalid)
|
|
|
|
printf("<invalid>%lu", rem);
|
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
int
|
|
|
|
main(int argc, char *argv[])
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
|
|
|
int ch, ktrlen, size;
|
2002-07-28 16:05:07 +00:00
|
|
|
void *m;
|
1994-05-27 12:33:43 +00:00
|
|
|
int trpoints = ALL_POINTS;
|
2003-03-13 18:46:35 +00:00
|
|
|
int drop_logged;
|
2003-06-03 01:44:43 +00:00
|
|
|
pid_t pid = 0;
|
2011-02-25 22:07:23 +00:00
|
|
|
u_int sv_flags;
|
1994-05-27 12:33:43 +00:00
|
|
|
|
2011-10-08 12:28:06 +00:00
|
|
|
setlocale(LC_CTYPE, "");
|
1995-10-26 22:16:45 +00:00
|
|
|
|
2014-03-25 23:37:57 +00:00
|
|
|
timestamp = TIMESTAMP_NONE;
|
|
|
|
|
2022-07-16 09:46:12 +00:00
|
|
|
while ((ch = getopt(argc,argv,"f:cdElm:np:AHRrSsTt:")) != -1)
|
2011-10-08 12:28:06 +00:00
|
|
|
switch (ch) {
|
2011-02-25 22:07:23 +00:00
|
|
|
case 'A':
|
2018-08-18 20:23:53 +00:00
|
|
|
abiflag = true;
|
2011-02-25 22:07:23 +00:00
|
|
|
break;
|
1994-05-27 12:33:43 +00:00
|
|
|
case 'f':
|
|
|
|
tracefile = optarg;
|
|
|
|
break;
|
2022-07-16 09:46:12 +00:00
|
|
|
case 'c':
|
|
|
|
cpuflag = true;
|
|
|
|
break;
|
1994-05-27 12:33:43 +00:00
|
|
|
case 'd':
|
2018-08-18 20:23:53 +00:00
|
|
|
decimal = true;
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
case 'l':
|
2018-08-18 20:23:53 +00:00
|
|
|
tail = true;
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
case 'm':
|
|
|
|
maxdata = atoi(optarg);
|
|
|
|
break;
|
|
|
|
case 'n':
|
2018-08-18 20:23:53 +00:00
|
|
|
fancy = false;
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
2003-06-03 01:44:43 +00:00
|
|
|
case 'p':
|
|
|
|
pid = atoi(optarg);
|
|
|
|
break;
|
2008-02-23 01:01:49 +00:00
|
|
|
case 'r':
|
2018-08-18 20:23:53 +00:00
|
|
|
resolv = true;
|
2008-02-23 01:01:49 +00:00
|
|
|
break;
|
2014-03-28 16:11:20 +00:00
|
|
|
case 'S':
|
2018-08-18 20:23:53 +00:00
|
|
|
syscallno = true;
|
2014-03-28 16:11:20 +00:00
|
|
|
break;
|
2005-11-12 14:21:48 +00:00
|
|
|
case 's':
|
2018-08-18 20:23:53 +00:00
|
|
|
suppressdata = true;
|
2005-11-12 14:21:48 +00:00
|
|
|
break;
|
2003-12-07 01:06:32 +00:00
|
|
|
case 'E':
|
2014-03-25 23:37:57 +00:00
|
|
|
timestamp |= TIMESTAMP_ELAPSED;
|
2003-12-07 01:06:32 +00:00
|
|
|
break;
|
2005-11-01 14:48:23 +00:00
|
|
|
case 'H':
|
2018-08-18 20:23:53 +00:00
|
|
|
threads = true;
|
2005-11-01 14:48:23 +00:00
|
|
|
break;
|
1994-05-27 12:33:43 +00:00
|
|
|
case 'R':
|
2014-03-25 23:37:57 +00:00
|
|
|
timestamp |= TIMESTAMP_RELATIVE;
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
case 'T':
|
2014-03-25 23:37:57 +00:00
|
|
|
timestamp |= TIMESTAMP_ABSOLUTE;
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
trpoints = getpoints(optarg);
|
1997-07-16 06:49:49 +00:00
|
|
|
if (trpoints < 0)
|
|
|
|
errx(1, "unknown trace point in %s", optarg);
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
1996-11-18 19:37:52 +00:00
|
|
|
if (argc > optind)
|
1994-05-27 12:33:43 +00:00
|
|
|
usage();
|
|
|
|
|
2011-10-08 12:28:06 +00:00
|
|
|
m = malloc(size = 1025);
|
1997-07-16 06:49:49 +00:00
|
|
|
if (m == NULL)
|
|
|
|
errx(1, "%s", strerror(ENOMEM));
|
2016-05-17 00:27:18 +00:00
|
|
|
if (strcmp(tracefile, "-") != 0)
|
2016-05-17 00:08:43 +00:00
|
|
|
if (!freopen(tracefile, "r", stdin))
|
|
|
|
err(1, "%s", tracefile);
|
2013-05-28 21:25:28 +00:00
|
|
|
|
2018-01-03 07:43:04 +00:00
|
|
|
caph_cache_catpages();
|
|
|
|
caph_cache_tzdata();
|
|
|
|
|
2017-09-21 14:41:41 +00:00
|
|
|
#ifdef WITH_CASPER
|
2018-08-18 20:23:53 +00:00
|
|
|
if (resolv) {
|
2013-12-15 23:09:05 +00:00
|
|
|
if (cappwdgrp_setup(&cappwd, &capgrp) < 0) {
|
|
|
|
cappwd = NULL;
|
|
|
|
capgrp = NULL;
|
|
|
|
}
|
|
|
|
}
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv || (cappwd != NULL && capgrp != NULL)) {
|
2018-06-19 23:43:14 +00:00
|
|
|
if (caph_enter() < 0)
|
2013-12-15 23:09:05 +00:00
|
|
|
err(1, "unable to enter capability mode");
|
|
|
|
}
|
|
|
|
#else
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv) {
|
2018-06-19 23:43:14 +00:00
|
|
|
if (caph_enter() < 0)
|
2013-05-30 21:59:29 +00:00
|
|
|
err(1, "unable to enter capability mode");
|
|
|
|
}
|
2013-12-15 23:09:05 +00:00
|
|
|
#endif
|
2016-10-07 17:56:57 +00:00
|
|
|
if (caph_limit_stdio() == -1)
|
|
|
|
err(1, "unable to limit stdio");
|
2013-05-28 21:25:28 +00:00
|
|
|
|
2011-02-25 22:07:23 +00:00
|
|
|
TAILQ_INIT(&trace_procs);
|
2003-03-13 18:46:35 +00:00
|
|
|
drop_logged = 0;
|
1994-05-27 12:33:43 +00:00
|
|
|
while (fread_tail(&ktr_header, sizeof(struct ktr_header), 1)) {
|
2022-07-16 09:46:12 +00:00
|
|
|
if (ktr_header.ktr_type & KTR_VERSIONED) {
|
|
|
|
ktr_header.ktr_type &= ~KTR_VERSIONED;
|
|
|
|
version = ktr_header.ktr_version;
|
|
|
|
} else
|
|
|
|
version = KTR_VERSION0;
|
2003-03-13 18:46:35 +00:00
|
|
|
if (ktr_header.ktr_type & KTR_DROP) {
|
|
|
|
ktr_header.ktr_type &= ~KTR_DROP;
|
2005-11-01 14:48:23 +00:00
|
|
|
if (!drop_logged && threads) {
|
2011-10-08 12:28:06 +00:00
|
|
|
printf(
|
2022-09-17 08:21:32 +00:00
|
|
|
"%6d %6d %-8.*s Events dropped.\n",
|
|
|
|
ktr_header.ktr_pid,
|
2010-02-06 16:01:38 +00:00
|
|
|
ktr_header.ktr_tid > 0 ?
|
2022-09-17 08:21:32 +00:00
|
|
|
(lwpid_t)ktr_header.ktr_tid : 0,
|
2010-02-06 16:01:38 +00:00
|
|
|
MAXCOMLEN, ktr_header.ktr_comm);
|
2005-11-01 14:48:23 +00:00
|
|
|
drop_logged = 1;
|
|
|
|
} else if (!drop_logged) {
|
2022-09-17 08:21:32 +00:00
|
|
|
printf("%6d %-8.*s Events dropped.\n",
|
|
|
|
ktr_header.ktr_pid, MAXCOMLEN,
|
2003-03-13 18:46:35 +00:00
|
|
|
ktr_header.ktr_comm);
|
|
|
|
drop_logged = 1;
|
|
|
|
}
|
|
|
|
}
|
1997-07-16 06:49:49 +00:00
|
|
|
if ((ktrlen = ktr_header.ktr_len) < 0)
|
|
|
|
errx(1, "bogus length 0x%x", ktrlen);
|
1994-05-27 12:33:43 +00:00
|
|
|
if (ktrlen > size) {
|
2011-10-08 12:28:06 +00:00
|
|
|
m = realloc(m, ktrlen+1);
|
1997-07-16 06:49:49 +00:00
|
|
|
if (m == NULL)
|
|
|
|
errx(1, "%s", strerror(ENOMEM));
|
1994-05-27 12:33:43 +00:00
|
|
|
size = ktrlen;
|
|
|
|
}
|
2022-07-16 09:46:12 +00:00
|
|
|
if (version == KTR_VERSION0 &&
|
|
|
|
fseek(stdin, KTR_OFFSET_V0, SEEK_CUR) < 0)
|
|
|
|
errx(1, "%s", strerror(errno));
|
1997-07-16 06:49:49 +00:00
|
|
|
if (ktrlen && fread_tail(m, ktrlen, 1) == 0)
|
|
|
|
errx(1, "data too short");
|
2011-02-25 22:07:23 +00:00
|
|
|
if (fetchprocinfo(&ktr_header, (u_int *)m) != 0)
|
|
|
|
continue;
|
2012-06-04 19:09:14 +00:00
|
|
|
if (pid && ktr_header.ktr_pid != pid &&
|
|
|
|
ktr_header.ktr_tid != pid)
|
2003-06-03 01:44:43 +00:00
|
|
|
continue;
|
1994-05-27 12:33:43 +00:00
|
|
|
if ((trpoints & (1<<ktr_header.ktr_type)) == 0)
|
|
|
|
continue;
|
2018-08-07 00:10:58 +00:00
|
|
|
sv_flags = findabi(&ktr_header);
|
|
|
|
dumpheader(&ktr_header, sv_flags);
|
2003-03-13 18:46:35 +00:00
|
|
|
drop_logged = 0;
|
1994-05-27 12:33:43 +00:00
|
|
|
switch (ktr_header.ktr_type) {
|
|
|
|
case KTR_SYSCALL:
|
2016-01-26 19:07:09 +00:00
|
|
|
ktrsyscall((struct ktr_syscall *)m, sv_flags);
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
case KTR_SYSRET:
|
2016-02-23 20:00:55 +00:00
|
|
|
ktrsysret((struct ktr_sysret *)m, sv_flags);
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
case KTR_NAMEI:
|
2009-03-11 21:48:36 +00:00
|
|
|
case KTR_SYSCTL:
|
1994-05-27 12:33:43 +00:00
|
|
|
ktrnamei(m, ktrlen);
|
|
|
|
break;
|
|
|
|
case KTR_GENIO:
|
|
|
|
ktrgenio((struct ktr_genio *)m, ktrlen);
|
|
|
|
break;
|
|
|
|
case KTR_PSIG:
|
2011-03-01 16:42:28 +00:00
|
|
|
ktrpsig((struct ktr_psig *)m);
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
|
|
|
case KTR_CSW:
|
2012-04-20 15:32:36 +00:00
|
|
|
if (ktrlen == sizeof(struct ktr_csw_old))
|
|
|
|
ktrcsw_old((struct ktr_csw_old *)m);
|
|
|
|
else
|
|
|
|
ktrcsw((struct ktr_csw *)m);
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
1996-09-19 19:50:45 +00:00
|
|
|
case KTR_USER:
|
1996-09-22 18:18:20 +00:00
|
|
|
ktruser(ktrlen, m);
|
1996-09-19 19:50:45 +00:00
|
|
|
break;
|
2008-02-23 01:01:49 +00:00
|
|
|
case KTR_STRUCT:
|
|
|
|
ktrstruct(m, ktrlen);
|
|
|
|
break;
|
2011-10-11 20:37:10 +00:00
|
|
|
case KTR_CAPFAIL:
|
|
|
|
ktrcapfail((struct ktr_cap_fail *)m);
|
2012-04-05 17:13:14 +00:00
|
|
|
break;
|
|
|
|
case KTR_FAULT:
|
|
|
|
ktrfault((struct ktr_fault *)m);
|
|
|
|
break;
|
|
|
|
case KTR_FAULTEND:
|
|
|
|
ktrfaultend((struct ktr_faultend *)m);
|
|
|
|
break;
|
2017-11-25 04:49:12 +00:00
|
|
|
case KTR_STRUCT_ARRAY:
|
|
|
|
ktrstructarray((struct ktr_struct_array *)m, ktrlen);
|
|
|
|
break;
|
2003-03-13 18:58:39 +00:00
|
|
|
default:
|
|
|
|
printf("\n");
|
|
|
|
break;
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
if (tail)
|
2011-10-08 12:28:06 +00:00
|
|
|
fflush(stdout);
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
2002-07-28 16:05:07 +00:00
|
|
|
return 0;
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
int
|
|
|
|
fread_tail(void *buf, int size, int num)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
while ((i = fread(buf, size, num, stdin)) == 0 && tail) {
|
2011-10-08 12:28:06 +00:00
|
|
|
sleep(1);
|
1994-05-27 12:33:43 +00:00
|
|
|
clearerr(stdin);
|
|
|
|
}
|
|
|
|
return (i);
|
|
|
|
}
|
|
|
|
|
2011-02-25 22:07:23 +00:00
|
|
|
int
|
|
|
|
fetchprocinfo(struct ktr_header *kth, u_int *flags)
|
|
|
|
{
|
|
|
|
struct proc_info *pi;
|
|
|
|
|
|
|
|
switch (kth->ktr_type) {
|
|
|
|
case KTR_PROCCTOR:
|
|
|
|
TAILQ_FOREACH(pi, &trace_procs, info) {
|
|
|
|
if (pi->pid == kth->ktr_pid) {
|
|
|
|
TAILQ_REMOVE(&trace_procs, pi, info);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pi = malloc(sizeof(struct proc_info));
|
|
|
|
if (pi == NULL)
|
|
|
|
errx(1, "%s", strerror(ENOMEM));
|
|
|
|
pi->sv_flags = *flags;
|
|
|
|
pi->pid = kth->ktr_pid;
|
|
|
|
TAILQ_INSERT_TAIL(&trace_procs, pi, info);
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
case KTR_PROCDTOR:
|
|
|
|
TAILQ_FOREACH(pi, &trace_procs, info) {
|
|
|
|
if (pi->pid == kth->ktr_pid) {
|
|
|
|
TAILQ_REMOVE(&trace_procs, pi, info);
|
|
|
|
free(pi);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
u_int
|
2018-08-07 00:10:58 +00:00
|
|
|
findabi(struct ktr_header *kth)
|
2011-02-25 22:07:23 +00:00
|
|
|
{
|
|
|
|
struct proc_info *pi;
|
|
|
|
|
|
|
|
TAILQ_FOREACH(pi, &trace_procs, info) {
|
|
|
|
if (pi->pid == kth->ktr_pid) {
|
2018-08-07 00:10:58 +00:00
|
|
|
return (pi->sv_flags);
|
2011-02-25 22:07:23 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-07 00:10:58 +00:00
|
|
|
return (0);
|
2011-02-25 22:07:23 +00:00
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
2022-07-16 09:46:12 +00:00
|
|
|
dumptimeval(struct ktr_header_v0 *kth)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
2016-10-01 22:17:40 +00:00
|
|
|
static struct timeval prevtime, prevtime_e;
|
|
|
|
struct timeval temp;
|
2022-07-16 09:46:12 +00:00
|
|
|
const char *sign;
|
|
|
|
|
|
|
|
if (timestamp & TIMESTAMP_ABSOLUTE) {
|
|
|
|
printf("%jd.%06ld ", (intmax_t)kth->ktr_time.tv_sec,
|
|
|
|
kth->ktr_time.tv_usec);
|
|
|
|
}
|
|
|
|
if (timestamp & TIMESTAMP_ELAPSED) {
|
|
|
|
if (prevtime_e.tv_sec == 0)
|
|
|
|
prevtime_e = kth->ktr_time;
|
|
|
|
timersub(&kth->ktr_time, &prevtime_e, &temp);
|
|
|
|
printf("%jd.%06ld ", (intmax_t)temp.tv_sec,
|
|
|
|
temp.tv_usec);
|
|
|
|
}
|
|
|
|
if (timestamp & TIMESTAMP_RELATIVE) {
|
|
|
|
if (prevtime.tv_sec == 0)
|
|
|
|
prevtime = kth->ktr_time;
|
|
|
|
if (timercmp(&kth->ktr_time, &prevtime, <)) {
|
|
|
|
timersub(&prevtime, &kth->ktr_time, &temp);
|
|
|
|
sign = "-";
|
|
|
|
} else {
|
|
|
|
timersub(&kth->ktr_time, &prevtime, &temp);
|
|
|
|
sign = "";
|
|
|
|
}
|
|
|
|
prevtime = kth->ktr_time;
|
|
|
|
printf("%s%jd.%06ld ", sign, (intmax_t)temp.tv_sec,
|
|
|
|
temp.tv_usec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dumptimespec(struct ktr_header *kth)
|
|
|
|
{
|
|
|
|
static struct timespec prevtime, prevtime_e;
|
|
|
|
struct timespec temp;
|
|
|
|
const char *sign;
|
|
|
|
|
|
|
|
if (timestamp & TIMESTAMP_ABSOLUTE) {
|
|
|
|
printf("%jd.%09ld ", (intmax_t)kth->ktr_time.tv_sec,
|
|
|
|
kth->ktr_time.tv_nsec);
|
|
|
|
}
|
|
|
|
if (timestamp & TIMESTAMP_ELAPSED) {
|
|
|
|
if (prevtime_e.tv_sec == 0)
|
|
|
|
prevtime_e = kth->ktr_time;
|
|
|
|
timespecsub(&kth->ktr_time, &prevtime_e, &temp);
|
|
|
|
printf("%jd.%09ld ", (intmax_t)temp.tv_sec,
|
|
|
|
temp.tv_nsec);
|
|
|
|
}
|
|
|
|
if (timestamp & TIMESTAMP_RELATIVE) {
|
|
|
|
if (prevtime.tv_sec == 0)
|
|
|
|
prevtime = kth->ktr_time;
|
|
|
|
if (timespeccmp(&kth->ktr_time, &prevtime, <)) {
|
|
|
|
timespecsub(&prevtime, &kth->ktr_time, &temp);
|
|
|
|
sign = "-";
|
|
|
|
} else {
|
|
|
|
timespecsub(&kth->ktr_time, &prevtime, &temp);
|
|
|
|
sign = "";
|
|
|
|
}
|
|
|
|
prevtime = kth->ktr_time;
|
|
|
|
printf("%s%jd.%09ld ", sign, (intmax_t)temp.tv_sec,
|
|
|
|
temp.tv_nsec);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
dumpheader(struct ktr_header *kth, u_int sv_flags)
|
|
|
|
{
|
|
|
|
static char unknown[64];
|
2018-08-07 00:10:58 +00:00
|
|
|
const char *abi;
|
|
|
|
const char *arch;
|
2002-07-28 16:05:07 +00:00
|
|
|
const char *type;
|
1994-05-27 12:33:43 +00:00
|
|
|
|
|
|
|
switch (kth->ktr_type) {
|
|
|
|
case KTR_SYSCALL:
|
|
|
|
type = "CALL";
|
|
|
|
break;
|
|
|
|
case KTR_SYSRET:
|
|
|
|
type = "RET ";
|
|
|
|
break;
|
|
|
|
case KTR_NAMEI:
|
|
|
|
type = "NAMI";
|
|
|
|
break;
|
|
|
|
case KTR_GENIO:
|
|
|
|
type = "GIO ";
|
|
|
|
break;
|
|
|
|
case KTR_PSIG:
|
|
|
|
type = "PSIG";
|
|
|
|
break;
|
|
|
|
case KTR_CSW:
|
2007-07-10 00:01:30 +00:00
|
|
|
type = "CSW ";
|
1994-05-27 12:33:43 +00:00
|
|
|
break;
|
1996-09-19 19:50:45 +00:00
|
|
|
case KTR_USER:
|
|
|
|
type = "USER";
|
|
|
|
break;
|
2008-02-23 01:01:49 +00:00
|
|
|
case KTR_STRUCT:
|
2017-11-25 04:49:12 +00:00
|
|
|
case KTR_STRUCT_ARRAY:
|
2008-02-23 01:01:49 +00:00
|
|
|
type = "STRU";
|
|
|
|
break;
|
2009-03-11 21:48:36 +00:00
|
|
|
case KTR_SYSCTL:
|
|
|
|
type = "SCTL";
|
|
|
|
break;
|
2011-10-11 20:37:10 +00:00
|
|
|
case KTR_CAPFAIL:
|
|
|
|
type = "CAP ";
|
|
|
|
break;
|
2012-04-05 17:13:14 +00:00
|
|
|
case KTR_FAULT:
|
|
|
|
type = "PFLT";
|
|
|
|
break;
|
|
|
|
case KTR_FAULTEND:
|
|
|
|
type = "PRET";
|
|
|
|
break;
|
1994-05-27 12:33:43 +00:00
|
|
|
default:
|
2011-10-08 12:28:06 +00:00
|
|
|
sprintf(unknown, "UNKNOWN(%d)", kth->ktr_type);
|
1994-05-27 12:33:43 +00:00
|
|
|
type = unknown;
|
|
|
|
}
|
|
|
|
|
2005-11-01 14:48:23 +00:00
|
|
|
/*
|
|
|
|
* The ktr_tid field was previously the ktr_buffer field, which held
|
|
|
|
* the kernel pointer value for the buffer associated with data
|
|
|
|
* following the record header. It now holds a threadid, but only
|
|
|
|
* for trace files after the change. Older trace files still contain
|
|
|
|
* kernel pointers. Detect this and suppress the results by printing
|
|
|
|
* negative tid's as 0.
|
|
|
|
*/
|
|
|
|
if (threads)
|
2022-09-17 08:21:32 +00:00
|
|
|
printf("%6d %6d %-8.*s ", kth->ktr_pid,
|
|
|
|
kth->ktr_tid > 0 ? (lwpid_t)kth->ktr_tid : 0,
|
2010-02-06 16:01:38 +00:00
|
|
|
MAXCOMLEN, kth->ktr_comm);
|
2005-11-01 14:48:23 +00:00
|
|
|
else
|
2022-09-17 08:21:32 +00:00
|
|
|
printf("%6d %-8.*s ", kth->ktr_pid, MAXCOMLEN, kth->ktr_comm);
|
2014-03-25 23:37:57 +00:00
|
|
|
if (timestamp) {
|
2022-07-16 09:46:12 +00:00
|
|
|
if (version == KTR_VERSION0)
|
|
|
|
dumptimeval((struct ktr_header_v0 *)kth);
|
|
|
|
else
|
|
|
|
dumptimespec(kth);
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
2022-07-16 09:46:12 +00:00
|
|
|
if (cpuflag && version > KTR_VERSION0)
|
|
|
|
printf("%3d ", kth->ktr_cpu);
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("%s ", type);
|
2018-08-07 00:10:58 +00:00
|
|
|
if (abiflag != 0) {
|
|
|
|
switch (sv_flags & SV_ABI_MASK) {
|
|
|
|
case SV_ABI_LINUX:
|
|
|
|
abi = "L";
|
|
|
|
break;
|
|
|
|
case SV_ABI_FREEBSD:
|
|
|
|
abi = "F";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
abi = "U";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((sv_flags & SV_LP64) != 0)
|
|
|
|
arch = "64";
|
|
|
|
else if ((sv_flags & SV_ILP32) != 0)
|
|
|
|
arch = "32";
|
|
|
|
else
|
|
|
|
arch = "00";
|
|
|
|
|
|
|
|
printf("%s%s ", abi, arch);
|
|
|
|
}
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#include <sys/syscall.h>
|
|
|
|
|
2015-12-22 20:33:49 +00:00
|
|
|
static void
|
|
|
|
ioctlname(unsigned long val)
|
|
|
|
{
|
|
|
|
const char *str;
|
|
|
|
|
|
|
|
str = sysdecode_ioctlname(val);
|
|
|
|
if (str != NULL)
|
|
|
|
printf("%s", str);
|
|
|
|
else if (decimal)
|
|
|
|
printf("%lu", val);
|
|
|
|
else
|
|
|
|
printf("%#lx", val);
|
|
|
|
}
|
|
|
|
|
2016-01-26 19:07:09 +00:00
|
|
|
static enum sysdecode_abi
|
|
|
|
syscallabi(u_int sv_flags)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (sv_flags == 0)
|
2016-01-30 01:00:54 +00:00
|
|
|
return (SYSDECODE_ABI_FREEBSD);
|
2016-01-26 19:07:09 +00:00
|
|
|
switch (sv_flags & SV_ABI_MASK) {
|
|
|
|
case SV_ABI_FREEBSD:
|
2016-01-30 01:00:54 +00:00
|
|
|
return (SYSDECODE_ABI_FREEBSD);
|
2016-01-26 19:07:09 +00:00
|
|
|
case SV_ABI_LINUX:
|
2018-04-24 19:23:26 +00:00
|
|
|
#ifdef __LP64__
|
2016-01-26 19:07:09 +00:00
|
|
|
if (sv_flags & SV_ILP32)
|
2016-01-30 01:00:54 +00:00
|
|
|
return (SYSDECODE_ABI_LINUX32);
|
2016-01-26 19:07:09 +00:00
|
|
|
#endif
|
2016-01-30 01:00:54 +00:00
|
|
|
return (SYSDECODE_ABI_LINUX);
|
2016-01-26 19:07:09 +00:00
|
|
|
default:
|
2016-01-30 01:00:54 +00:00
|
|
|
return (SYSDECODE_ABI_UNKNOWN);
|
2016-01-26 19:07:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
syscallname(u_int code, u_int sv_flags)
|
|
|
|
{
|
|
|
|
const char *name;
|
|
|
|
|
|
|
|
name = sysdecode_syscallname(syscallabi(sv_flags), code);
|
|
|
|
if (name == NULL)
|
|
|
|
printf("[%d]", code);
|
|
|
|
else {
|
|
|
|
printf("%s", name);
|
|
|
|
if (syscallno)
|
|
|
|
printf("[%d]", code);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
static void
|
|
|
|
print_signal(int signo)
|
|
|
|
{
|
|
|
|
const char *signame;
|
|
|
|
|
|
|
|
signame = sysdecode_signal(signo);
|
|
|
|
if (signame != NULL)
|
|
|
|
printf("%s", signame);
|
|
|
|
else
|
|
|
|
printf("SIG %d", signo);
|
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
2016-01-26 19:07:09 +00:00
|
|
|
ktrsyscall(struct ktr_syscall *ktr, u_int sv_flags)
|
2022-06-22 11:03:56 +00:00
|
|
|
{
|
|
|
|
int narg = ktr->ktr_narg;
|
|
|
|
register_t *ip;
|
|
|
|
|
|
|
|
syscallname(ktr->ktr_code, sv_flags);
|
|
|
|
ip = &ktr->ktr_args[0];
|
|
|
|
if (narg) {
|
|
|
|
char c = '(';
|
|
|
|
if (fancy) {
|
|
|
|
switch (sv_flags & SV_ABI_MASK) {
|
|
|
|
case SV_ABI_FREEBSD:
|
|
|
|
ktrsyscall_freebsd(ktr, &ip, &narg, &c,
|
|
|
|
sv_flags);
|
|
|
|
break;
|
|
|
|
#ifdef SYSDECODE_HAVE_LINUX
|
|
|
|
case SV_ABI_LINUX:
|
|
|
|
#ifdef __amd64__
|
|
|
|
if (sv_flags & SV_ILP32)
|
|
|
|
ktrsyscall_linux32(ktr, &ip,
|
|
|
|
&narg, &c);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
ktrsyscall_linux(ktr, &ip, &narg, &c);
|
|
|
|
break;
|
|
|
|
#endif /* SYSDECODE_HAVE_LINUX */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
while (narg > 0)
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
putchar(')');
|
|
|
|
}
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ktrsyscall_freebsd(struct ktr_syscall *ktr, register_t **resip,
|
|
|
|
int *resnarg, char *resc, u_int sv_flags)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
2002-07-28 16:05:07 +00:00
|
|
|
int narg = ktr->ktr_narg;
|
2016-10-01 22:01:41 +00:00
|
|
|
register_t *ip, *first;
|
2011-10-11 20:37:10 +00:00
|
|
|
intmax_t arg;
|
2016-10-01 22:01:41 +00:00
|
|
|
int quad_align, quad_slots;
|
1994-05-27 12:33:43 +00:00
|
|
|
|
2016-10-01 22:01:41 +00:00
|
|
|
ip = first = &ktr->ktr_args[0];
|
2022-06-22 11:03:56 +00:00
|
|
|
char c = *resc;
|
|
|
|
|
2016-10-01 22:01:41 +00:00
|
|
|
quad_align = 0;
|
|
|
|
if (sv_flags & SV_ILP32) {
|
|
|
|
#ifdef __powerpc__
|
|
|
|
quad_align = 1;
|
|
|
|
#endif
|
|
|
|
quad_slots = 2;
|
|
|
|
} else
|
|
|
|
quad_slots = 1;
|
2013-08-13 19:57:35 +00:00
|
|
|
switch (ktr->ktr_code) {
|
2013-08-13 20:33:50 +00:00
|
|
|
case SYS_bindat:
|
2017-03-15 22:36:26 +00:00
|
|
|
case SYS_chflagsat:
|
2013-08-13 20:33:50 +00:00
|
|
|
case SYS_connectat:
|
2013-08-13 19:57:35 +00:00
|
|
|
case SYS_faccessat:
|
|
|
|
case SYS_fchmodat:
|
|
|
|
case SYS_fchownat:
|
|
|
|
case SYS_fstatat:
|
|
|
|
case SYS_futimesat:
|
|
|
|
case SYS_linkat:
|
|
|
|
case SYS_mkdirat:
|
|
|
|
case SYS_mkfifoat:
|
|
|
|
case SYS_mknodat:
|
|
|
|
case SYS_openat:
|
|
|
|
case SYS_readlinkat:
|
|
|
|
case SYS_renameat:
|
|
|
|
case SYS_unlinkat:
|
2015-01-23 21:07:08 +00:00
|
|
|
case SYS_utimensat:
|
2013-08-13 19:57:35 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg_valid(sysdecode_atfd, *ip);
|
2013-08-13 19:57:35 +00:00
|
|
|
c = ',';
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
break;
|
|
|
|
}
|
2011-10-08 11:51:48 +00:00
|
|
|
switch (ktr->ktr_code) {
|
|
|
|
case SYS_ioctl: {
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:47:00 +00:00
|
|
|
putchar(c);
|
2015-12-22 20:33:49 +00:00
|
|
|
ioctlname(*ip);
|
1994-05-27 12:33:43 +00:00
|
|
|
c = ',';
|
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SYS_ptrace:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_ptrace_request, *ip);
|
1994-05-27 12:33:43 +00:00
|
|
|
c = ',';
|
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_access:
|
|
|
|
case SYS_eaccess:
|
2013-08-13 19:57:35 +00:00
|
|
|
case SYS_faccessat:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_access_mode, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2022-03-03 12:45:11 +00:00
|
|
|
case SYS_close_range:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
putchar(',');
|
|
|
|
print_mask_arg(sysdecode_close_range_flags, *ip);
|
|
|
|
ip += 3;
|
|
|
|
narg -= 3;
|
|
|
|
break;
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_open:
|
2013-08-13 19:57:35 +00:00
|
|
|
case SYS_openat:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_open_flags, ip[0]);
|
|
|
|
if ((ip[0] & O_CREAT) == O_CREAT) {
|
|
|
|
putchar(',');
|
|
|
|
decode_filemode(ip[1]);
|
|
|
|
}
|
2011-10-08 11:51:48 +00:00
|
|
|
ip += 2;
|
|
|
|
narg -= 2;
|
|
|
|
break;
|
|
|
|
case SYS_wait4:
|
2013-09-12 18:08:25 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
putchar(',');
|
|
|
|
print_mask_arg0(sysdecode_wait4_options, *ip);
|
|
|
|
ip++;
|
|
|
|
narg--;
|
2013-09-12 18:08:25 +00:00
|
|
|
break;
|
|
|
|
case SYS_wait6:
|
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_idtype, *ip);
|
2013-09-12 18:08:25 +00:00
|
|
|
c = ',';
|
|
|
|
ip++;
|
|
|
|
narg--;
|
2016-10-01 22:01:41 +00:00
|
|
|
print_number64(first, ip, narg, c);
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_wait6_options, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_chmod:
|
|
|
|
case SYS_fchmod:
|
|
|
|
case SYS_lchmod:
|
2016-05-03 21:27:17 +00:00
|
|
|
case SYS_fchmodat:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
decode_filemode(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2013-08-13 19:57:35 +00:00
|
|
|
case SYS_mknodat:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
decode_filemode(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_getfsstat:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
2017-01-03 01:39:05 +00:00
|
|
|
print_integer_arg(sysdecode_getfsstat_mode, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_mount:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mount_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_unmount:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mount_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_recvmsg:
|
|
|
|
case SYS_sendmsg:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg0(sysdecode_msg_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_recvfrom:
|
|
|
|
case SYS_sendto:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg0(sysdecode_msg_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_chflags:
|
2017-03-15 22:36:26 +00:00
|
|
|
case SYS_chflagsat:
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_fchflags:
|
|
|
|
case SYS_lchflags:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
decode_fileflags(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_kill:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_signal(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_reboot:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_reboot_howto, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_umask:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
decode_filemode(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_msync:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_msync_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2007-07-04 23:32:49 +00:00
|
|
|
#ifdef SYS_freebsd6_mmap
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_freebsd6_mmap:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mmap_prot, *ip);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
2007-07-04 23:32:49 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mmap_flags, *ip);
|
2007-07-04 23:32:49 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2007-07-04 23:32:49 +00:00
|
|
|
#endif
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_mmap:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mmap_prot, *ip);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mmap_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_mprotect:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mmap_prot, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_madvise:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_madvice, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2017-09-04 05:34:36 +00:00
|
|
|
case SYS_pathconf:
|
|
|
|
case SYS_lpathconf:
|
|
|
|
case SYS_fpathconf:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
putchar(',');
|
|
|
|
print_integer_arg(sysdecode_pathconf_name, *ip);
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
break;
|
2017-06-10 00:35:45 +00:00
|
|
|
case SYS_getpriority:
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_setpriority:
|
2017-06-10 00:35:45 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_prio_which, *ip);
|
2017-06-10 00:35:45 +00:00
|
|
|
c = ',';
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_fcntl:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_fcntl_cmd, ip[0]);
|
|
|
|
if (sysdecode_fcntl_arg_p(ip[0])) {
|
|
|
|
putchar(',');
|
|
|
|
if (ip[0] == F_SETFL)
|
|
|
|
print_mask_arg(
|
|
|
|
sysdecode_fcntl_fileflags,
|
|
|
|
ip[1]);
|
|
|
|
else
|
|
|
|
sysdecode_fcntl_arg(stdout,
|
|
|
|
ip[0], ip[1],
|
|
|
|
decimal ? 10 : 16);
|
|
|
|
}
|
2011-10-08 11:51:48 +00:00
|
|
|
ip += 2;
|
|
|
|
narg -= 2;
|
|
|
|
break;
|
|
|
|
case SYS_socket: {
|
2007-01-04 04:46:59 +00:00
|
|
|
int sockdomain;
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
2011-10-08 21:02:08 +00:00
|
|
|
sockdomain = *ip;
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_socketdomain,
|
|
|
|
sockdomain);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_socket_type, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2007-01-04 04:46:59 +00:00
|
|
|
if (sockdomain == PF_INET ||
|
|
|
|
sockdomain == PF_INET6) {
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_ipproto,
|
|
|
|
*ip);
|
2007-01-04 04:46:59 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
}
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case SYS_setsockopt:
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
case SYS_getsockopt: {
|
|
|
|
const char *str;
|
|
|
|
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg_valid(sysdecode_sockopt_level,
|
|
|
|
*ip);
|
|
|
|
str = sysdecode_sockopt_name(ip[0], ip[1]);
|
|
|
|
if (str != NULL) {
|
|
|
|
printf(",%s", str);
|
2008-01-07 18:50:25 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
}
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
}
|
2007-07-04 23:32:49 +00:00
|
|
|
#ifdef SYS_freebsd6_lseek
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_freebsd6_lseek:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
/* Hidden 'pad' argument, not in lseek(2) */
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2016-10-01 22:01:41 +00:00
|
|
|
print_number64(first, ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_whence, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2007-07-04 23:32:49 +00:00
|
|
|
#endif
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_lseek:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2016-10-01 22:01:41 +00:00
|
|
|
print_number64(first, ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_whence, *ip);
|
2007-07-04 23:32:49 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_flock:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_flock_operation, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_mkfifo:
|
2013-08-13 19:57:35 +00:00
|
|
|
case SYS_mkfifoat:
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_mkdir:
|
2013-08-13 19:57:35 +00:00
|
|
|
case SYS_mkdirat:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
decode_filemode(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_shutdown:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_shutdown_how, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_socketpair:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_socketdomain, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_socket_type, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_getrlimit:
|
|
|
|
case SYS_setrlimit:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_rlimit, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2017-06-03 14:22:15 +00:00
|
|
|
case SYS_getrusage:
|
|
|
|
putchar('(');
|
|
|
|
print_integer_arg(sysdecode_getrusage_who, *ip);
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
|
|
|
break;
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_quotactl:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
if (!sysdecode_quotactl_cmd(stdout, *ip)) {
|
|
|
|
if (decimal)
|
|
|
|
printf("<invalid=%d>", (int)*ip);
|
|
|
|
else
|
|
|
|
printf("<invalid=%#x>",
|
|
|
|
(int)*ip);
|
|
|
|
}
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_nfssvc:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_nfssvc_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_rtprio:
|
2017-06-10 01:32:18 +00:00
|
|
|
case SYS_rtprio_thread:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_rtprio_function,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS___semctl:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_semctl_cmd, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_semget:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_semget_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_msgctl:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_msgctl_cmd, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_shmat:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_shmat_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_shmctl:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_shmctl_cmd, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2019-09-25 18:09:19 +00:00
|
|
|
#ifdef SYS_freebsd12_shm_open
|
|
|
|
case SYS_freebsd12_shm_open:
|
2020-02-19 14:32:55 +00:00
|
|
|
if (ip[0] == (uintptr_t)SHM_ANON) {
|
|
|
|
printf("(SHM_ANON");
|
|
|
|
ip++;
|
|
|
|
} else {
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
}
|
2014-08-01 23:28:21 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_open_flags, ip[0]);
|
|
|
|
putchar(',');
|
|
|
|
decode_filemode(ip[1]);
|
|
|
|
ip += 2;
|
|
|
|
narg -= 2;
|
2014-08-01 23:28:21 +00:00
|
|
|
break;
|
2019-09-25 18:09:19 +00:00
|
|
|
#endif
|
2020-02-19 14:55:59 +00:00
|
|
|
case SYS_shm_open2:
|
|
|
|
if (ip[0] == (uintptr_t)SHM_ANON) {
|
|
|
|
printf("(SHM_ANON");
|
|
|
|
ip++;
|
|
|
|
} else {
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
}
|
|
|
|
putchar(',');
|
|
|
|
print_mask_arg(sysdecode_open_flags, ip[0]);
|
|
|
|
putchar(',');
|
|
|
|
decode_filemode(ip[1]);
|
|
|
|
putchar(',');
|
|
|
|
print_mask_arg(sysdecode_shmflags, ip[2]);
|
|
|
|
ip += 3;
|
|
|
|
narg -= 3;
|
|
|
|
break;
|
2011-10-08 11:51:48 +00:00
|
|
|
case SYS_minherit:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_minherit_inherit,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_rfork:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_rfork_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_lio_listio:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_lio_listio_mode,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_mlockall:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mlockall_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_sched_setscheduler:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_scheduler_policy,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_sched_get_priority_max:
|
|
|
|
case SYS_sched_get_priority_min:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_scheduler_policy,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_sendfile:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_sendfile_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_kldsym:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_kldsym_cmd, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_sigprocmask:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_sigprocmask_how,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS___acl_get_file:
|
|
|
|
case SYS___acl_set_file:
|
|
|
|
case SYS___acl_get_fd:
|
|
|
|
case SYS___acl_set_fd:
|
|
|
|
case SYS___acl_delete_file:
|
|
|
|
case SYS___acl_delete_fd:
|
|
|
|
case SYS___acl_aclcheck_file:
|
|
|
|
case SYS___acl_aclcheck_fd:
|
|
|
|
case SYS___acl_get_link:
|
|
|
|
case SYS___acl_set_link:
|
|
|
|
case SYS___acl_delete_link:
|
|
|
|
case SYS___acl_aclcheck_link:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_acltype, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_sigaction:
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_signal(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_extattrctl:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_extattrnamespace,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_nmount:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_mount_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_thr_create:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_thr_create_flags, *ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_thr_kill:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_signal(*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
|
|
|
case SYS_kldunloadf:
|
2011-10-08 12:10:16 +00:00
|
|
|
print_number(ip, narg, c);
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_kldunload_flags,
|
|
|
|
*ip);
|
Change kdump to print more useful information, i.e. it changes from
32229 telnet CALL mmap(0,0x8000,0x3,0x1002,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,0,0x1b6)
32229 telnet CALL socket(0x2,0x2,0)
to
32229 telnet CALL mmap(0,0x8000,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,0xffffffff,0,0,0)
32229 telnet CALL open(0x2807bc28,O_RDONLY,<unused>0x1b6)
32229 telnet CALL socket(PF_INET,SOCK_DGRAM,0)
David wanted to implement the suggestions which came up at the review from
arch@ too, but real life rejected this proposal. So I commit what we already
got and let another volunteer pick the remaining work from the ideas list.
Submitted by: "David Kirchner" <dpk@dpk.net>
Suggested by: FreeBSD ideas list page
Reviewed by: arch
2006-05-20 14:27:22 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2011-10-08 11:51:48 +00:00
|
|
|
break;
|
2013-08-13 19:57:35 +00:00
|
|
|
case SYS_linkat:
|
|
|
|
case SYS_renameat:
|
|
|
|
case SYS_symlinkat:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg_valid(sysdecode_atfd, *ip);
|
2013-08-13 19:57:35 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
2017-09-04 05:34:36 +00:00
|
|
|
print_number(ip, narg, c);
|
2013-08-13 19:57:35 +00:00
|
|
|
break;
|
Merge Capsicum overhaul:
- Capability is no longer separate descriptor type. Now every descriptor
has set of its own capability rights.
- The cap_new(2) system call is left, but it is no longer documented and
should not be used in new code.
- The new syscall cap_rights_limit(2) should be used instead of
cap_new(2), which limits capability rights of the given descriptor
without creating a new one.
- The cap_getrights(2) syscall is renamed to cap_rights_get(2).
- If CAP_IOCTL capability right is present we can further reduce allowed
ioctls list with the new cap_ioctls_limit(2) syscall. List of allowed
ioctls can be retrived with cap_ioctls_get(2) syscall.
- If CAP_FCNTL capability right is present we can further reduce fcntls
that can be used with the new cap_fcntls_limit(2) syscall and retrive
them with cap_fcntls_get(2).
- To support ioctl and fcntl white-listing the filedesc structure was
heavly modified.
- The audit subsystem, kdump and procstat tools were updated to
recognize new syscalls.
- Capability rights were revised and eventhough I tried hard to provide
backward API and ABI compatibility there are some incompatible changes
that are described in detail below:
CAP_CREATE old behaviour:
- Allow for openat(2)+O_CREAT.
- Allow for linkat(2).
- Allow for symlinkat(2).
CAP_CREATE new behaviour:
- Allow for openat(2)+O_CREAT.
Added CAP_LINKAT:
- Allow for linkat(2). ABI: Reuses CAP_RMDIR bit.
- Allow to be target for renameat(2).
Added CAP_SYMLINKAT:
- Allow for symlinkat(2).
Removed CAP_DELETE. Old behaviour:
- Allow for unlinkat(2) when removing non-directory object.
- Allow to be source for renameat(2).
Removed CAP_RMDIR. Old behaviour:
- Allow for unlinkat(2) when removing directory.
Added CAP_RENAMEAT:
- Required for source directory for the renameat(2) syscall.
Added CAP_UNLINKAT (effectively it replaces CAP_DELETE and CAP_RMDIR):
- Allow for unlinkat(2) on any object.
- Required if target of renameat(2) exists and will be removed by this
call.
Removed CAP_MAPEXEC.
CAP_MMAP old behaviour:
- Allow for mmap(2) with any combination of PROT_NONE, PROT_READ and
PROT_WRITE.
CAP_MMAP new behaviour:
- Allow for mmap(2)+PROT_NONE.
Added CAP_MMAP_R:
- Allow for mmap(PROT_READ).
Added CAP_MMAP_W:
- Allow for mmap(PROT_WRITE).
Added CAP_MMAP_X:
- Allow for mmap(PROT_EXEC).
Added CAP_MMAP_RW:
- Allow for mmap(PROT_READ | PROT_WRITE).
Added CAP_MMAP_RX:
- Allow for mmap(PROT_READ | PROT_EXEC).
Added CAP_MMAP_WX:
- Allow for mmap(PROT_WRITE | PROT_EXEC).
Added CAP_MMAP_RWX:
- Allow for mmap(PROT_READ | PROT_WRITE | PROT_EXEC).
Renamed CAP_MKDIR to CAP_MKDIRAT.
Renamed CAP_MKFIFO to CAP_MKFIFOAT.
Renamed CAP_MKNODE to CAP_MKNODEAT.
CAP_READ old behaviour:
- Allow pread(2).
- Disallow read(2), readv(2) (if there is no CAP_SEEK).
CAP_READ new behaviour:
- Allow read(2), readv(2).
- Disallow pread(2) (CAP_SEEK was also required).
CAP_WRITE old behaviour:
- Allow pwrite(2).
- Disallow write(2), writev(2) (if there is no CAP_SEEK).
CAP_WRITE new behaviour:
- Allow write(2), writev(2).
- Disallow pwrite(2) (CAP_SEEK was also required).
Added convinient defines:
#define CAP_PREAD (CAP_SEEK | CAP_READ)
#define CAP_PWRITE (CAP_SEEK | CAP_WRITE)
#define CAP_MMAP_R (CAP_MMAP | CAP_SEEK | CAP_READ)
#define CAP_MMAP_W (CAP_MMAP | CAP_SEEK | CAP_WRITE)
#define CAP_MMAP_X (CAP_MMAP | CAP_SEEK | 0x0000000000000008ULL)
#define CAP_MMAP_RW (CAP_MMAP_R | CAP_MMAP_W)
#define CAP_MMAP_RX (CAP_MMAP_R | CAP_MMAP_X)
#define CAP_MMAP_WX (CAP_MMAP_W | CAP_MMAP_X)
#define CAP_MMAP_RWX (CAP_MMAP_R | CAP_MMAP_W | CAP_MMAP_X)
#define CAP_RECV CAP_READ
#define CAP_SEND CAP_WRITE
#define CAP_SOCK_CLIENT \
(CAP_CONNECT | CAP_GETPEERNAME | CAP_GETSOCKNAME | CAP_GETSOCKOPT | \
CAP_PEELOFF | CAP_RECV | CAP_SEND | CAP_SETSOCKOPT | CAP_SHUTDOWN)
#define CAP_SOCK_SERVER \
(CAP_ACCEPT | CAP_BIND | CAP_GETPEERNAME | CAP_GETSOCKNAME | \
CAP_GETSOCKOPT | CAP_LISTEN | CAP_PEELOFF | CAP_RECV | CAP_SEND | \
CAP_SETSOCKOPT | CAP_SHUTDOWN)
Added defines for backward API compatibility:
#define CAP_MAPEXEC CAP_MMAP_X
#define CAP_DELETE CAP_UNLINKAT
#define CAP_MKDIR CAP_MKDIRAT
#define CAP_RMDIR CAP_UNLINKAT
#define CAP_MKFIFO CAP_MKFIFOAT
#define CAP_MKNOD CAP_MKNODAT
#define CAP_SOCK_ALL (CAP_SOCK_CLIENT | CAP_SOCK_SERVER)
Sponsored by: The FreeBSD Foundation
Reviewed by: Christoph Mallon <christoph.mallon@gmx.de>
Many aspects discussed with: rwatson, benl, jonathan
ABI compatibility discussed with: kib
2013-03-02 00:53:12 +00:00
|
|
|
case SYS_cap_fcntls_limit:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
putchar(',');
|
|
|
|
arg = *ip;
|
|
|
|
ip++;
|
|
|
|
narg--;
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg32(sysdecode_cap_fcntlrights, arg);
|
Merge Capsicum overhaul:
- Capability is no longer separate descriptor type. Now every descriptor
has set of its own capability rights.
- The cap_new(2) system call is left, but it is no longer documented and
should not be used in new code.
- The new syscall cap_rights_limit(2) should be used instead of
cap_new(2), which limits capability rights of the given descriptor
without creating a new one.
- The cap_getrights(2) syscall is renamed to cap_rights_get(2).
- If CAP_IOCTL capability right is present we can further reduce allowed
ioctls list with the new cap_ioctls_limit(2) syscall. List of allowed
ioctls can be retrived with cap_ioctls_get(2) syscall.
- If CAP_FCNTL capability right is present we can further reduce fcntls
that can be used with the new cap_fcntls_limit(2) syscall and retrive
them with cap_fcntls_get(2).
- To support ioctl and fcntl white-listing the filedesc structure was
heavly modified.
- The audit subsystem, kdump and procstat tools were updated to
recognize new syscalls.
- Capability rights were revised and eventhough I tried hard to provide
backward API and ABI compatibility there are some incompatible changes
that are described in detail below:
CAP_CREATE old behaviour:
- Allow for openat(2)+O_CREAT.
- Allow for linkat(2).
- Allow for symlinkat(2).
CAP_CREATE new behaviour:
- Allow for openat(2)+O_CREAT.
Added CAP_LINKAT:
- Allow for linkat(2). ABI: Reuses CAP_RMDIR bit.
- Allow to be target for renameat(2).
Added CAP_SYMLINKAT:
- Allow for symlinkat(2).
Removed CAP_DELETE. Old behaviour:
- Allow for unlinkat(2) when removing non-directory object.
- Allow to be source for renameat(2).
Removed CAP_RMDIR. Old behaviour:
- Allow for unlinkat(2) when removing directory.
Added CAP_RENAMEAT:
- Required for source directory for the renameat(2) syscall.
Added CAP_UNLINKAT (effectively it replaces CAP_DELETE and CAP_RMDIR):
- Allow for unlinkat(2) on any object.
- Required if target of renameat(2) exists and will be removed by this
call.
Removed CAP_MAPEXEC.
CAP_MMAP old behaviour:
- Allow for mmap(2) with any combination of PROT_NONE, PROT_READ and
PROT_WRITE.
CAP_MMAP new behaviour:
- Allow for mmap(2)+PROT_NONE.
Added CAP_MMAP_R:
- Allow for mmap(PROT_READ).
Added CAP_MMAP_W:
- Allow for mmap(PROT_WRITE).
Added CAP_MMAP_X:
- Allow for mmap(PROT_EXEC).
Added CAP_MMAP_RW:
- Allow for mmap(PROT_READ | PROT_WRITE).
Added CAP_MMAP_RX:
- Allow for mmap(PROT_READ | PROT_EXEC).
Added CAP_MMAP_WX:
- Allow for mmap(PROT_WRITE | PROT_EXEC).
Added CAP_MMAP_RWX:
- Allow for mmap(PROT_READ | PROT_WRITE | PROT_EXEC).
Renamed CAP_MKDIR to CAP_MKDIRAT.
Renamed CAP_MKFIFO to CAP_MKFIFOAT.
Renamed CAP_MKNODE to CAP_MKNODEAT.
CAP_READ old behaviour:
- Allow pread(2).
- Disallow read(2), readv(2) (if there is no CAP_SEEK).
CAP_READ new behaviour:
- Allow read(2), readv(2).
- Disallow pread(2) (CAP_SEEK was also required).
CAP_WRITE old behaviour:
- Allow pwrite(2).
- Disallow write(2), writev(2) (if there is no CAP_SEEK).
CAP_WRITE new behaviour:
- Allow write(2), writev(2).
- Disallow pwrite(2) (CAP_SEEK was also required).
Added convinient defines:
#define CAP_PREAD (CAP_SEEK | CAP_READ)
#define CAP_PWRITE (CAP_SEEK | CAP_WRITE)
#define CAP_MMAP_R (CAP_MMAP | CAP_SEEK | CAP_READ)
#define CAP_MMAP_W (CAP_MMAP | CAP_SEEK | CAP_WRITE)
#define CAP_MMAP_X (CAP_MMAP | CAP_SEEK | 0x0000000000000008ULL)
#define CAP_MMAP_RW (CAP_MMAP_R | CAP_MMAP_W)
#define CAP_MMAP_RX (CAP_MMAP_R | CAP_MMAP_X)
#define CAP_MMAP_WX (CAP_MMAP_W | CAP_MMAP_X)
#define CAP_MMAP_RWX (CAP_MMAP_R | CAP_MMAP_W | CAP_MMAP_X)
#define CAP_RECV CAP_READ
#define CAP_SEND CAP_WRITE
#define CAP_SOCK_CLIENT \
(CAP_CONNECT | CAP_GETPEERNAME | CAP_GETSOCKNAME | CAP_GETSOCKOPT | \
CAP_PEELOFF | CAP_RECV | CAP_SEND | CAP_SETSOCKOPT | CAP_SHUTDOWN)
#define CAP_SOCK_SERVER \
(CAP_ACCEPT | CAP_BIND | CAP_GETPEERNAME | CAP_GETSOCKNAME | \
CAP_GETSOCKOPT | CAP_LISTEN | CAP_PEELOFF | CAP_RECV | CAP_SEND | \
CAP_SETSOCKOPT | CAP_SHUTDOWN)
Added defines for backward API compatibility:
#define CAP_MAPEXEC CAP_MMAP_X
#define CAP_DELETE CAP_UNLINKAT
#define CAP_MKDIR CAP_MKDIRAT
#define CAP_RMDIR CAP_UNLINKAT
#define CAP_MKFIFO CAP_MKFIFOAT
#define CAP_MKNOD CAP_MKNODAT
#define CAP_SOCK_ALL (CAP_SOCK_CLIENT | CAP_SOCK_SERVER)
Sponsored by: The FreeBSD Foundation
Reviewed by: Christoph Mallon <christoph.mallon@gmx.de>
Many aspects discussed with: rwatson, benl, jonathan
ABI compatibility discussed with: kib
2013-03-02 00:53:12 +00:00
|
|
|
break;
|
2012-02-23 21:08:21 +00:00
|
|
|
case SYS_posix_fadvise:
|
2012-02-24 20:12:53 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
2012-02-23 21:08:21 +00:00
|
|
|
(void)putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_fadvice, *ip);
|
2012-02-23 21:08:21 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
break;
|
2013-09-19 18:53:42 +00:00
|
|
|
case SYS_procctl:
|
|
|
|
putchar('(');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_idtype, *ip);
|
2013-09-19 18:53:42 +00:00
|
|
|
c = ',';
|
|
|
|
ip++;
|
|
|
|
narg--;
|
2016-10-01 22:01:41 +00:00
|
|
|
print_number64(first, ip, narg, c);
|
2013-09-19 18:53:42 +00:00
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_integer_arg(sysdecode_procctl_cmd, *ip);
|
2013-09-19 18:53:42 +00:00
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
break;
|
kdump/truss: decode new _umtx_op flags
In both cases, print the flag bits first followed by the command.
Output now looks something like this:
(ktrace)
_umtx_op(0x8605f7008,0xf<UMTX_OP_WAIT_UINT_PRIVATE>,0,0,0)
_umtx_op(0x9fffdce8,0x80000003<UMTX_OP__32BIT|UMTX_OP_WAKE>,0x1,0,0)
(truss)
_umtx_op(0x7fffffffda50,UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
_umtx_op(0x9fffdd08,UMTX_OP__32BIT|UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
Reviewed by: kib
Differential Revision: https://reviews.freebsd.org/D27325
2020-12-09 03:24:09 +00:00
|
|
|
case SYS__umtx_op: {
|
|
|
|
int op;
|
|
|
|
|
2014-10-13 16:37:06 +00:00
|
|
|
print_number(ip, narg, c);
|
|
|
|
putchar(',');
|
kdump/truss: decode new _umtx_op flags
In both cases, print the flag bits first followed by the command.
Output now looks something like this:
(ktrace)
_umtx_op(0x8605f7008,0xf<UMTX_OP_WAIT_UINT_PRIVATE>,0,0,0)
_umtx_op(0x9fffdce8,0x80000003<UMTX_OP__32BIT|UMTX_OP_WAKE>,0x1,0,0)
(truss)
_umtx_op(0x7fffffffda50,UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
_umtx_op(0x9fffdd08,UMTX_OP__32BIT|UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
Reviewed by: kib
Differential Revision: https://reviews.freebsd.org/D27325
2020-12-09 03:24:09 +00:00
|
|
|
if (print_mask_arg_part(sysdecode_umtx_op_flags,
|
|
|
|
*ip, &op))
|
|
|
|
putchar('|');
|
|
|
|
print_integer_arg(sysdecode_umtx_op, op);
|
|
|
|
putchar('>');
|
2014-10-13 16:37:06 +00:00
|
|
|
switch (*ip) {
|
|
|
|
case UMTX_OP_CV_WAIT:
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_argul(
|
|
|
|
sysdecode_umtx_cvwait_flags, *ip);
|
2014-10-13 16:37:06 +00:00
|
|
|
break;
|
|
|
|
case UMTX_OP_RW_RDLOCK:
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
putchar(',');
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_argul(
|
|
|
|
sysdecode_umtx_rwlock_flags, *ip);
|
2014-10-13 16:37:06 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
ip++;
|
|
|
|
narg--;
|
2016-10-01 22:03:41 +00:00
|
|
|
break;
|
kdump/truss: decode new _umtx_op flags
In both cases, print the flag bits first followed by the command.
Output now looks something like this:
(ktrace)
_umtx_op(0x8605f7008,0xf<UMTX_OP_WAIT_UINT_PRIVATE>,0,0,0)
_umtx_op(0x9fffdce8,0x80000003<UMTX_OP__32BIT|UMTX_OP_WAKE>,0x1,0,0)
(truss)
_umtx_op(0x7fffffffda50,UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
_umtx_op(0x9fffdd08,UMTX_OP__32BIT|UMTX_OP_WAKE,0x1,0x0,0x0) = 0 (0x0)
Reviewed by: kib
Differential Revision: https://reviews.freebsd.org/D27325
2020-12-09 03:24:09 +00:00
|
|
|
}
|
2016-10-01 22:03:41 +00:00
|
|
|
case SYS_ftruncate:
|
|
|
|
case SYS_truncate:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number64(first, ip, narg, c);
|
|
|
|
break;
|
2017-09-04 05:34:36 +00:00
|
|
|
case SYS_fchownat:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
break;
|
|
|
|
case SYS_fstatat:
|
|
|
|
case SYS_utimensat:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
break;
|
|
|
|
case SYS_unlinkat:
|
|
|
|
print_number(ip, narg, c);
|
|
|
|
break;
|
|
|
|
case SYS_sysarch:
|
|
|
|
putchar('(');
|
|
|
|
print_integer_arg(sysdecode_sysarch_number, *ip);
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
|
|
|
break;
|
2022-06-22 11:19:31 +00:00
|
|
|
case SYS_getitimer:
|
|
|
|
case SYS_setitimer:
|
|
|
|
putchar('(');
|
|
|
|
print_integer_arg(sysdecode_itimer, *ip);
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
c = ',';
|
|
|
|
break;
|
2017-09-04 05:34:36 +00:00
|
|
|
}
|
|
|
|
switch (ktr->ktr_code) {
|
|
|
|
case SYS_chflagsat:
|
|
|
|
case SYS_fchownat:
|
|
|
|
case SYS_faccessat:
|
|
|
|
case SYS_fchmodat:
|
|
|
|
case SYS_fstatat:
|
|
|
|
case SYS_linkat:
|
|
|
|
case SYS_unlinkat:
|
|
|
|
case SYS_utimensat:
|
|
|
|
putchar(',');
|
|
|
|
print_mask_arg0(sysdecode_atflags, *ip);
|
|
|
|
ip++;
|
|
|
|
narg--;
|
|
|
|
break;
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
2022-06-22 11:03:56 +00:00
|
|
|
*resc = c;
|
|
|
|
*resip = ip;
|
|
|
|
*resnarg = narg;
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
2016-01-26 19:07:09 +00:00
|
|
|
ktrsysret(struct ktr_sysret *ktr, u_int sv_flags)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
2002-07-28 16:05:07 +00:00
|
|
|
register_t ret = ktr->ktr_retval;
|
|
|
|
int error = ktr->ktr_error;
|
1994-05-27 12:33:43 +00:00
|
|
|
|
2016-01-26 19:07:09 +00:00
|
|
|
syscallname(ktr->ktr_code, sv_flags);
|
|
|
|
printf(" ");
|
1994-05-27 12:33:43 +00:00
|
|
|
|
|
|
|
if (error == 0) {
|
|
|
|
if (fancy) {
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("%ld", (long)ret);
|
1994-05-27 12:33:43 +00:00
|
|
|
if (ret < 0 || ret > 9)
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("/%#lx", (unsigned long)ret);
|
1994-05-27 12:33:43 +00:00
|
|
|
} else {
|
|
|
|
if (decimal)
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("%ld", (long)ret);
|
1994-05-27 12:33:43 +00:00
|
|
|
else
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("%#lx", (unsigned long)ret);
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
} else if (error == ERESTART)
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("RESTART");
|
1994-05-27 12:33:43 +00:00
|
|
|
else if (error == EJUSTRETURN)
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("JUSTRETURN");
|
1994-05-27 12:33:43 +00:00
|
|
|
else {
|
2016-02-23 20:00:55 +00:00
|
|
|
printf("-1 errno %d", sysdecode_freebsd_to_abi_errno(
|
|
|
|
syscallabi(sv_flags), error));
|
1994-05-27 12:33:43 +00:00
|
|
|
if (fancy)
|
2011-10-08 12:28:06 +00:00
|
|
|
printf(" %s", strerror(ktr->ktr_error));
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('\n');
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
|
|
|
ktrnamei(char *cp, int len)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("\"%.*s\"\n", len, cp);
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
2003-06-03 01:44:43 +00:00
|
|
|
hexdump(char *p, int len, int screenwidth)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
2003-06-03 01:44:43 +00:00
|
|
|
int n, i;
|
2002-07-28 16:05:07 +00:00
|
|
|
int width;
|
1994-05-27 12:33:43 +00:00
|
|
|
|
2003-06-03 01:44:43 +00:00
|
|
|
width = 0;
|
|
|
|
do {
|
|
|
|
width += 2;
|
|
|
|
i = 13; /* base offset */
|
|
|
|
i += (width / 2) + 1; /* spaces every second byte */
|
|
|
|
i += (width * 2); /* width of bytes */
|
|
|
|
i += 3; /* " |" */
|
|
|
|
i += width; /* each byte */
|
|
|
|
i += 1; /* "|" */
|
|
|
|
} while (i < screenwidth);
|
|
|
|
width -= 2;
|
1994-05-27 12:33:43 +00:00
|
|
|
|
2003-06-03 01:44:43 +00:00
|
|
|
for (n = 0; n < len; n += width) {
|
|
|
|
for (i = n; i < n + width; i++) {
|
|
|
|
if ((i % width) == 0) { /* beginning of line */
|
|
|
|
printf(" 0x%04x", i);
|
|
|
|
}
|
|
|
|
if ((i % 2) == 0) {
|
|
|
|
printf(" ");
|
|
|
|
}
|
|
|
|
if (i < len)
|
|
|
|
printf("%02x", p[i] & 0xff);
|
|
|
|
else
|
|
|
|
printf(" ");
|
|
|
|
}
|
|
|
|
printf(" |");
|
|
|
|
for (i = n; i < n + width; i++) {
|
|
|
|
if (i >= len)
|
|
|
|
break;
|
|
|
|
if (p[i] >= ' ' && p[i] <= '~')
|
|
|
|
printf("%c", p[i]);
|
|
|
|
else
|
|
|
|
printf(".");
|
|
|
|
}
|
|
|
|
printf("|\n");
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
2003-06-03 01:44:43 +00:00
|
|
|
if ((i % width) != 0)
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
visdump(char *dp, int datalen, int screenwidth)
|
|
|
|
{
|
|
|
|
int col = 0;
|
|
|
|
char *cp;
|
|
|
|
int width;
|
|
|
|
char visbuf[5];
|
|
|
|
|
2011-10-08 12:28:06 +00:00
|
|
|
printf(" \"");
|
1994-05-27 12:33:43 +00:00
|
|
|
col = 8;
|
|
|
|
for (;datalen > 0; datalen--, dp++) {
|
2021-06-16 15:28:27 +00:00
|
|
|
vis(visbuf, *dp, VIS_CSTYLE | VIS_NOLOCALE, *(dp+1));
|
1994-05-27 12:33:43 +00:00
|
|
|
cp = visbuf;
|
|
|
|
/*
|
|
|
|
* Keep track of printables and
|
|
|
|
* space chars (like fold(1)).
|
|
|
|
*/
|
|
|
|
if (col == 0) {
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('\t');
|
1994-05-27 12:33:43 +00:00
|
|
|
col = 8;
|
|
|
|
}
|
|
|
|
switch(*cp) {
|
|
|
|
case '\n':
|
|
|
|
col = 0;
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar('\n');
|
1994-05-27 12:33:43 +00:00
|
|
|
continue;
|
|
|
|
case '\t':
|
|
|
|
width = 8 - (col&07);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
width = strlen(cp);
|
|
|
|
}
|
|
|
|
if (col + width > (screenwidth-2)) {
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("\\\n\t");
|
1994-05-27 12:33:43 +00:00
|
|
|
col = 8;
|
|
|
|
}
|
|
|
|
col += width;
|
|
|
|
do {
|
2011-10-08 12:28:06 +00:00
|
|
|
putchar(*cp++);
|
1994-05-27 12:33:43 +00:00
|
|
|
} while (*cp);
|
|
|
|
}
|
|
|
|
if (col == 0)
|
2011-10-08 12:28:06 +00:00
|
|
|
printf(" ");
|
|
|
|
printf("\"\n");
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
|
2003-06-03 01:44:43 +00:00
|
|
|
void
|
|
|
|
ktrgenio(struct ktr_genio *ktr, int len)
|
|
|
|
{
|
|
|
|
int datalen = len - sizeof (struct ktr_genio);
|
|
|
|
char *dp = (char *)ktr + sizeof (struct ktr_genio);
|
|
|
|
static int screenwidth = 0;
|
|
|
|
int i, binary;
|
|
|
|
|
2013-05-28 21:21:46 +00:00
|
|
|
printf("fd %d %s %d byte%s\n", ktr->ktr_fd,
|
|
|
|
ktr->ktr_rw == UIO_READ ? "read" : "wrote", datalen,
|
|
|
|
datalen == 1 ? "" : "s");
|
|
|
|
if (suppressdata)
|
|
|
|
return;
|
2003-06-03 01:44:43 +00:00
|
|
|
if (screenwidth == 0) {
|
|
|
|
struct winsize ws;
|
|
|
|
|
|
|
|
if (fancy && ioctl(fileno(stderr), TIOCGWINSZ, &ws) != -1 &&
|
|
|
|
ws.ws_col > 8)
|
|
|
|
screenwidth = ws.ws_col;
|
|
|
|
else
|
|
|
|
screenwidth = 80;
|
|
|
|
}
|
|
|
|
if (maxdata && datalen > maxdata)
|
|
|
|
datalen = maxdata;
|
|
|
|
|
|
|
|
for (i = 0, binary = 0; i < datalen && binary == 0; i++) {
|
|
|
|
if (dp[i] >= 32 && dp[i] < 127)
|
|
|
|
continue;
|
|
|
|
if (dp[i] == 10 || dp[i] == 13 || dp[i] == 0 || dp[i] == 9)
|
|
|
|
continue;
|
|
|
|
binary = 1;
|
|
|
|
}
|
|
|
|
if (binary)
|
|
|
|
hexdump(dp, datalen, screenwidth);
|
|
|
|
else
|
|
|
|
visdump(dp, datalen, screenwidth);
|
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
2011-03-01 16:42:28 +00:00
|
|
|
ktrpsig(struct ktr_psig *psig)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
const char *str;
|
|
|
|
|
|
|
|
print_signal(psig->signo);
|
2012-09-22 12:40:00 +00:00
|
|
|
if (psig->action == SIG_DFL) {
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
printf(" SIG_DFL");
|
2012-09-22 12:40:00 +00:00
|
|
|
} else {
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
printf(" caught handler=0x%lx mask=0x%x",
|
2012-09-22 12:40:00 +00:00
|
|
|
(u_long)psig->action, psig->mask.__bits[0]);
|
2002-07-28 16:05:07 +00:00
|
|
|
}
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
printf(" code=");
|
|
|
|
str = sysdecode_sigcode(psig->signo, psig->code);
|
|
|
|
if (str != NULL)
|
|
|
|
printf("%s", str);
|
|
|
|
else
|
|
|
|
printf("<invalid=%#x>", psig->code);
|
|
|
|
putchar('\n');
|
1994-05-27 12:33:43 +00:00
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
2012-04-20 15:32:36 +00:00
|
|
|
ktrcsw_old(struct ktr_csw_old *cs)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("%s %s\n", cs->out ? "stop" : "resume",
|
1994-05-27 12:33:43 +00:00
|
|
|
cs->user ? "user" : "kernel");
|
|
|
|
}
|
|
|
|
|
2012-04-20 15:32:36 +00:00
|
|
|
void
|
|
|
|
ktrcsw(struct ktr_csw *cs)
|
|
|
|
{
|
|
|
|
printf("%s %s \"%s\"\n", cs->out ? "stop" : "resume",
|
|
|
|
cs->user ? "user" : "kernel", cs->wmesg);
|
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
2014-10-13 16:17:42 +00:00
|
|
|
ktruser(int len, void *p)
|
1996-09-19 19:50:45 +00:00
|
|
|
{
|
2014-10-13 16:17:42 +00:00
|
|
|
unsigned char *cp;
|
2007-01-05 21:04:37 +00:00
|
|
|
|
2015-12-15 00:05:07 +00:00
|
|
|
if (sysdecode_utrace(stdout, p, len)) {
|
2015-10-06 21:58:38 +00:00
|
|
|
printf("\n");
|
2007-01-05 21:04:37 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("%d ", len);
|
2014-10-13 16:17:42 +00:00
|
|
|
cp = p;
|
1996-09-22 18:18:20 +00:00
|
|
|
while (len--)
|
2004-03-25 12:33:55 +00:00
|
|
|
if (decimal)
|
2014-10-13 16:17:42 +00:00
|
|
|
printf(" %d", *cp++);
|
2004-03-25 12:33:55 +00:00
|
|
|
else
|
2014-10-13 16:17:42 +00:00
|
|
|
printf(" %02x", *cp++);
|
2011-10-08 12:28:06 +00:00
|
|
|
printf("\n");
|
1996-09-19 19:50:45 +00:00
|
|
|
}
|
|
|
|
|
Change the cap_rights_t type from uint64_t to a structure that we can extend
in the future in a backward compatible (API and ABI) way.
The cap_rights_t represents capability rights. We used to use one bit to
represent one right, but we are running out of spare bits. Currently the new
structure provides place for 114 rights (so 50 more than the previous
cap_rights_t), but it is possible to grow the structure to hold at least 285
rights, although we can make it even larger if 285 rights won't be enough.
The structure definition looks like this:
struct cap_rights {
uint64_t cr_rights[CAP_RIGHTS_VERSION + 2];
};
The initial CAP_RIGHTS_VERSION is 0.
The top two bits in the first element of the cr_rights[] array contain total
number of elements in the array - 2. This means if those two bits are equal to
0, we have 2 array elements.
The top two bits in all remaining array elements should be 0.
The next five bits in all array elements contain array index. Only one bit is
used and bit position in this five-bits range defines array index. This means
there can be at most five array elements in the future.
To define new right the CAPRIGHT() macro must be used. The macro takes two
arguments - an array index and a bit to set, eg.
#define CAP_PDKILL CAPRIGHT(1, 0x0000000000000800ULL)
We still support aliases that combine few rights, but the rights have to belong
to the same array element, eg:
#define CAP_LOOKUP CAPRIGHT(0, 0x0000000000000400ULL)
#define CAP_FCHMOD CAPRIGHT(0, 0x0000000000002000ULL)
#define CAP_FCHMODAT (CAP_FCHMOD | CAP_LOOKUP)
There is new API to manage the new cap_rights_t structure:
cap_rights_t *cap_rights_init(cap_rights_t *rights, ...);
void cap_rights_set(cap_rights_t *rights, ...);
void cap_rights_clear(cap_rights_t *rights, ...);
bool cap_rights_is_set(const cap_rights_t *rights, ...);
bool cap_rights_is_valid(const cap_rights_t *rights);
void cap_rights_merge(cap_rights_t *dst, const cap_rights_t *src);
void cap_rights_remove(cap_rights_t *dst, const cap_rights_t *src);
bool cap_rights_contains(const cap_rights_t *big, const cap_rights_t *little);
Capability rights to the cap_rights_init(), cap_rights_set(),
cap_rights_clear() and cap_rights_is_set() functions are provided by
separating them with commas, eg:
cap_rights_t rights;
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FSTAT);
There is no need to terminate the list of rights, as those functions are
actually macros that take care of the termination, eg:
#define cap_rights_set(rights, ...) \
__cap_rights_set((rights), __VA_ARGS__, 0ULL)
void __cap_rights_set(cap_rights_t *rights, ...);
Thanks to using one bit as an array index we can assert in those functions that
there are no two rights belonging to different array elements provided
together. For example this is illegal and will be detected, because CAP_LOOKUP
belongs to element 0 and CAP_PDKILL to element 1:
cap_rights_init(&rights, CAP_LOOKUP | CAP_PDKILL);
Providing several rights that belongs to the same array's element this way is
correct, but is not advised. It should only be used for aliases definition.
This commit also breaks compatibility with some existing Capsicum system calls,
but I see no other way to do that. This should be fine as Capsicum is still
experimental and this change is not going to 9.x.
Sponsored by: The FreeBSD Foundation
2013-09-05 00:09:56 +00:00
|
|
|
void
|
|
|
|
ktrcaprights(cap_rights_t *rightsp)
|
|
|
|
{
|
|
|
|
|
|
|
|
printf("cap_rights_t ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
sysdecode_cap_rights(stdout, rightsp);
|
Change the cap_rights_t type from uint64_t to a structure that we can extend
in the future in a backward compatible (API and ABI) way.
The cap_rights_t represents capability rights. We used to use one bit to
represent one right, but we are running out of spare bits. Currently the new
structure provides place for 114 rights (so 50 more than the previous
cap_rights_t), but it is possible to grow the structure to hold at least 285
rights, although we can make it even larger if 285 rights won't be enough.
The structure definition looks like this:
struct cap_rights {
uint64_t cr_rights[CAP_RIGHTS_VERSION + 2];
};
The initial CAP_RIGHTS_VERSION is 0.
The top two bits in the first element of the cr_rights[] array contain total
number of elements in the array - 2. This means if those two bits are equal to
0, we have 2 array elements.
The top two bits in all remaining array elements should be 0.
The next five bits in all array elements contain array index. Only one bit is
used and bit position in this five-bits range defines array index. This means
there can be at most five array elements in the future.
To define new right the CAPRIGHT() macro must be used. The macro takes two
arguments - an array index and a bit to set, eg.
#define CAP_PDKILL CAPRIGHT(1, 0x0000000000000800ULL)
We still support aliases that combine few rights, but the rights have to belong
to the same array element, eg:
#define CAP_LOOKUP CAPRIGHT(0, 0x0000000000000400ULL)
#define CAP_FCHMOD CAPRIGHT(0, 0x0000000000002000ULL)
#define CAP_FCHMODAT (CAP_FCHMOD | CAP_LOOKUP)
There is new API to manage the new cap_rights_t structure:
cap_rights_t *cap_rights_init(cap_rights_t *rights, ...);
void cap_rights_set(cap_rights_t *rights, ...);
void cap_rights_clear(cap_rights_t *rights, ...);
bool cap_rights_is_set(const cap_rights_t *rights, ...);
bool cap_rights_is_valid(const cap_rights_t *rights);
void cap_rights_merge(cap_rights_t *dst, const cap_rights_t *src);
void cap_rights_remove(cap_rights_t *dst, const cap_rights_t *src);
bool cap_rights_contains(const cap_rights_t *big, const cap_rights_t *little);
Capability rights to the cap_rights_init(), cap_rights_set(),
cap_rights_clear() and cap_rights_is_set() functions are provided by
separating them with commas, eg:
cap_rights_t rights;
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FSTAT);
There is no need to terminate the list of rights, as those functions are
actually macros that take care of the termination, eg:
#define cap_rights_set(rights, ...) \
__cap_rights_set((rights), __VA_ARGS__, 0ULL)
void __cap_rights_set(cap_rights_t *rights, ...);
Thanks to using one bit as an array index we can assert in those functions that
there are no two rights belonging to different array elements provided
together. For example this is illegal and will be detected, because CAP_LOOKUP
belongs to element 0 and CAP_PDKILL to element 1:
cap_rights_init(&rights, CAP_LOOKUP | CAP_PDKILL);
Providing several rights that belongs to the same array's element this way is
correct, but is not advised. It should only be used for aliases definition.
This commit also breaks compatibility with some existing Capsicum system calls,
but I see no other way to do that. This should be fine as Capsicum is still
experimental and this change is not going to 9.x.
Sponsored by: The FreeBSD Foundation
2013-09-05 00:09:56 +00:00
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
2016-07-13 14:37:58 +00:00
|
|
|
static void
|
|
|
|
ktrtimeval(struct timeval *tv)
|
|
|
|
{
|
|
|
|
|
|
|
|
printf("{%ld, %ld}", (long)tv->tv_sec, tv->tv_usec);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ktritimerval(struct itimerval *it)
|
|
|
|
{
|
|
|
|
|
|
|
|
printf("itimerval { .interval = ");
|
|
|
|
ktrtimeval(&it->it_interval);
|
|
|
|
printf(", .value = ");
|
|
|
|
ktrtimeval(&it->it_value);
|
|
|
|
printf(" }\n");
|
|
|
|
}
|
|
|
|
|
2008-02-23 01:01:49 +00:00
|
|
|
void
|
|
|
|
ktrsockaddr(struct sockaddr *sa)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
TODO: Support additional address families
|
2013-06-28 21:00:08 +00:00
|
|
|
#include <netsmb/netbios.h>
|
|
|
|
struct sockaddr_nb *nb;
|
2008-02-23 01:01:49 +00:00
|
|
|
*/
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
const char *str;
|
2008-02-23 01:01:49 +00:00
|
|
|
char addr[64];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* note: ktrstruct() has already verified that sa points to a
|
|
|
|
* buffer at least sizeof(struct sockaddr) bytes long and exactly
|
|
|
|
* sa->sa_len bytes long.
|
|
|
|
*/
|
|
|
|
printf("struct sockaddr { ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
str = sysdecode_sockaddr_family(sa->sa_family);
|
|
|
|
if (str != NULL)
|
|
|
|
printf("%s", str);
|
|
|
|
else
|
|
|
|
printf("<invalid=%d>", sa->sa_family);
|
2008-02-23 01:01:49 +00:00
|
|
|
printf(", ");
|
|
|
|
|
|
|
|
#define check_sockaddr_len(n) \
|
2011-10-12 21:45:12 +00:00
|
|
|
if (sa_##n.s##n##_len < sizeof(struct sockaddr_##n)) { \
|
2008-02-23 01:01:49 +00:00
|
|
|
printf("invalid"); \
|
|
|
|
break; \
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(sa->sa_family) {
|
|
|
|
case AF_INET: {
|
2011-10-12 21:45:12 +00:00
|
|
|
struct sockaddr_in sa_in;
|
2008-02-23 01:01:49 +00:00
|
|
|
|
2011-10-12 21:45:12 +00:00
|
|
|
memset(&sa_in, 0, sizeof(sa_in));
|
2013-02-12 18:48:11 +00:00
|
|
|
memcpy(&sa_in, sa, sa->sa_len);
|
2008-02-23 01:01:49 +00:00
|
|
|
check_sockaddr_len(in);
|
2011-10-12 21:45:12 +00:00
|
|
|
inet_ntop(AF_INET, &sa_in.sin_addr, addr, sizeof addr);
|
|
|
|
printf("%s:%u", addr, ntohs(sa_in.sin_port));
|
2008-02-23 01:01:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case AF_INET6: {
|
2011-10-12 21:45:12 +00:00
|
|
|
struct sockaddr_in6 sa_in6;
|
2008-02-23 01:01:49 +00:00
|
|
|
|
2011-10-12 21:45:12 +00:00
|
|
|
memset(&sa_in6, 0, sizeof(sa_in6));
|
2013-02-12 18:48:11 +00:00
|
|
|
memcpy(&sa_in6, sa, sa->sa_len);
|
2008-02-23 01:01:49 +00:00
|
|
|
check_sockaddr_len(in6);
|
2013-06-07 08:06:48 +00:00
|
|
|
getnameinfo((struct sockaddr *)&sa_in6, sizeof(sa_in6),
|
|
|
|
addr, sizeof(addr), NULL, 0, NI_NUMERICHOST);
|
2011-10-12 21:45:12 +00:00
|
|
|
printf("[%s]:%u", addr, htons(sa_in6.sin6_port));
|
2008-02-23 01:01:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case AF_UNIX: {
|
2011-10-12 21:45:12 +00:00
|
|
|
struct sockaddr_un sa_un;
|
2008-02-23 01:01:49 +00:00
|
|
|
|
2011-10-12 21:45:12 +00:00
|
|
|
memset(&sa_un, 0, sizeof(sa_un));
|
2013-02-12 18:48:11 +00:00
|
|
|
memcpy(&sa_un, sa, sa->sa_len);
|
2011-10-12 21:45:12 +00:00
|
|
|
printf("%.*s", (int)sizeof(sa_un.sun_path), sa_un.sun_path);
|
2008-02-23 01:01:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
printf("unknown address family");
|
|
|
|
}
|
|
|
|
printf(" }\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ktrstat(struct stat *statp)
|
|
|
|
{
|
|
|
|
char mode[12], timestr[PATH_MAX + 4];
|
|
|
|
struct passwd *pwd;
|
|
|
|
struct group *grp;
|
|
|
|
struct tm *tm;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* note: ktrstruct() has already verified that statp points to a
|
|
|
|
* buffer exactly sizeof(struct stat) bytes long.
|
|
|
|
*/
|
|
|
|
printf("struct stat {");
|
2013-10-07 11:23:01 +00:00
|
|
|
printf("dev=%ju, ino=%ju, ",
|
|
|
|
(uintmax_t)statp->st_dev, (uintmax_t)statp->st_ino);
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv)
|
2013-10-07 11:23:01 +00:00
|
|
|
printf("mode=0%jo, ", (uintmax_t)statp->st_mode);
|
|
|
|
else {
|
|
|
|
strmode(statp->st_mode, mode);
|
|
|
|
printf("mode=%s, ", mode);
|
|
|
|
}
|
|
|
|
printf("nlink=%ju, ", (uintmax_t)statp->st_nlink);
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv) {
|
2013-12-15 23:09:05 +00:00
|
|
|
pwd = NULL;
|
|
|
|
} else {
|
2017-09-21 14:41:41 +00:00
|
|
|
#ifdef WITH_CASPER
|
2013-12-15 23:09:05 +00:00
|
|
|
if (cappwd != NULL)
|
|
|
|
pwd = cap_getpwuid(cappwd, statp->st_uid);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
pwd = getpwuid(statp->st_uid);
|
|
|
|
}
|
|
|
|
if (pwd == NULL)
|
2008-02-23 01:01:49 +00:00
|
|
|
printf("uid=%ju, ", (uintmax_t)statp->st_uid);
|
|
|
|
else
|
|
|
|
printf("uid=\"%s\", ", pwd->pw_name);
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv) {
|
2013-12-15 23:09:05 +00:00
|
|
|
grp = NULL;
|
|
|
|
} else {
|
2017-09-21 14:41:41 +00:00
|
|
|
#ifdef WITH_CASPER
|
2013-12-15 23:09:05 +00:00
|
|
|
if (capgrp != NULL)
|
|
|
|
grp = cap_getgrgid(capgrp, statp->st_gid);
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
grp = getgrgid(statp->st_gid);
|
|
|
|
}
|
|
|
|
if (grp == NULL)
|
2008-02-23 01:01:49 +00:00
|
|
|
printf("gid=%ju, ", (uintmax_t)statp->st_gid);
|
|
|
|
else
|
|
|
|
printf("gid=\"%s\", ", grp->gr_name);
|
|
|
|
printf("rdev=%ju, ", (uintmax_t)statp->st_rdev);
|
|
|
|
printf("atime=");
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv)
|
2010-03-28 13:16:08 +00:00
|
|
|
printf("%jd", (intmax_t)statp->st_atim.tv_sec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else {
|
2010-03-28 13:16:08 +00:00
|
|
|
tm = localtime(&statp->st_atim.tv_sec);
|
2011-10-08 12:28:06 +00:00
|
|
|
strftime(timestr, sizeof(timestr), TIME_FORMAT, tm);
|
2008-02-23 01:01:49 +00:00
|
|
|
printf("\"%s\"", timestr);
|
|
|
|
}
|
2010-03-28 13:16:08 +00:00
|
|
|
if (statp->st_atim.tv_nsec != 0)
|
|
|
|
printf(".%09ld, ", statp->st_atim.tv_nsec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else
|
|
|
|
printf(", ");
|
2016-05-22 18:20:45 +00:00
|
|
|
printf("mtime=");
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv)
|
2010-03-28 13:16:08 +00:00
|
|
|
printf("%jd", (intmax_t)statp->st_mtim.tv_sec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else {
|
2010-03-28 13:16:08 +00:00
|
|
|
tm = localtime(&statp->st_mtim.tv_sec);
|
2011-10-08 12:28:06 +00:00
|
|
|
strftime(timestr, sizeof(timestr), TIME_FORMAT, tm);
|
2008-02-23 01:01:49 +00:00
|
|
|
printf("\"%s\"", timestr);
|
|
|
|
}
|
2010-03-28 13:16:08 +00:00
|
|
|
if (statp->st_mtim.tv_nsec != 0)
|
|
|
|
printf(".%09ld, ", statp->st_mtim.tv_nsec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else
|
|
|
|
printf(", ");
|
|
|
|
printf("ctime=");
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv)
|
2010-03-28 13:16:08 +00:00
|
|
|
printf("%jd", (intmax_t)statp->st_ctim.tv_sec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else {
|
2010-03-28 13:16:08 +00:00
|
|
|
tm = localtime(&statp->st_ctim.tv_sec);
|
2011-10-08 12:28:06 +00:00
|
|
|
strftime(timestr, sizeof(timestr), TIME_FORMAT, tm);
|
2008-02-23 01:01:49 +00:00
|
|
|
printf("\"%s\"", timestr);
|
|
|
|
}
|
2010-03-28 13:16:08 +00:00
|
|
|
if (statp->st_ctim.tv_nsec != 0)
|
|
|
|
printf(".%09ld, ", statp->st_ctim.tv_nsec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else
|
|
|
|
printf(", ");
|
|
|
|
printf("birthtime=");
|
2018-08-18 20:23:53 +00:00
|
|
|
if (!resolv)
|
2010-03-28 13:16:08 +00:00
|
|
|
printf("%jd", (intmax_t)statp->st_birthtim.tv_sec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else {
|
2010-03-28 13:16:08 +00:00
|
|
|
tm = localtime(&statp->st_birthtim.tv_sec);
|
2011-10-08 12:28:06 +00:00
|
|
|
strftime(timestr, sizeof(timestr), TIME_FORMAT, tm);
|
2008-02-23 01:01:49 +00:00
|
|
|
printf("\"%s\"", timestr);
|
|
|
|
}
|
2010-03-28 13:16:08 +00:00
|
|
|
if (statp->st_birthtim.tv_nsec != 0)
|
|
|
|
printf(".%09ld, ", statp->st_birthtim.tv_nsec);
|
2008-02-23 01:01:49 +00:00
|
|
|
else
|
|
|
|
printf(", ");
|
|
|
|
printf("size=%jd, blksize=%ju, blocks=%jd, flags=0x%x",
|
|
|
|
(uintmax_t)statp->st_size, (uintmax_t)statp->st_blksize,
|
|
|
|
(intmax_t)statp->st_blocks, statp->st_flags);
|
|
|
|
printf(" }\n");
|
|
|
|
}
|
|
|
|
|
2022-05-11 07:40:39 +00:00
|
|
|
void
|
|
|
|
ktrbitset(char *name, struct bitset *set, size_t setlen)
|
|
|
|
{
|
|
|
|
int i, maxi, c = 0;
|
|
|
|
|
|
|
|
if (setlen > INT32_MAX)
|
|
|
|
setlen = INT32_MAX;
|
|
|
|
maxi = setlen * CHAR_BIT;
|
|
|
|
printf("%s [ ", name);
|
|
|
|
for (i = 0; i < maxi; i++) {
|
|
|
|
if (!BIT_ISSET(setlen, i, set))
|
|
|
|
continue;
|
|
|
|
if (c == 0)
|
|
|
|
printf("%d", i);
|
|
|
|
else
|
|
|
|
printf(", %d", i);
|
|
|
|
c++;
|
|
|
|
}
|
|
|
|
if (c == 0)
|
|
|
|
printf(" empty ]\n");
|
|
|
|
else
|
|
|
|
printf(" ]\n");
|
|
|
|
}
|
|
|
|
|
2008-02-23 01:01:49 +00:00
|
|
|
void
|
|
|
|
ktrstruct(char *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
char *name, *data;
|
|
|
|
size_t namelen, datalen;
|
|
|
|
int i;
|
Change the cap_rights_t type from uint64_t to a structure that we can extend
in the future in a backward compatible (API and ABI) way.
The cap_rights_t represents capability rights. We used to use one bit to
represent one right, but we are running out of spare bits. Currently the new
structure provides place for 114 rights (so 50 more than the previous
cap_rights_t), but it is possible to grow the structure to hold at least 285
rights, although we can make it even larger if 285 rights won't be enough.
The structure definition looks like this:
struct cap_rights {
uint64_t cr_rights[CAP_RIGHTS_VERSION + 2];
};
The initial CAP_RIGHTS_VERSION is 0.
The top two bits in the first element of the cr_rights[] array contain total
number of elements in the array - 2. This means if those two bits are equal to
0, we have 2 array elements.
The top two bits in all remaining array elements should be 0.
The next five bits in all array elements contain array index. Only one bit is
used and bit position in this five-bits range defines array index. This means
there can be at most five array elements in the future.
To define new right the CAPRIGHT() macro must be used. The macro takes two
arguments - an array index and a bit to set, eg.
#define CAP_PDKILL CAPRIGHT(1, 0x0000000000000800ULL)
We still support aliases that combine few rights, but the rights have to belong
to the same array element, eg:
#define CAP_LOOKUP CAPRIGHT(0, 0x0000000000000400ULL)
#define CAP_FCHMOD CAPRIGHT(0, 0x0000000000002000ULL)
#define CAP_FCHMODAT (CAP_FCHMOD | CAP_LOOKUP)
There is new API to manage the new cap_rights_t structure:
cap_rights_t *cap_rights_init(cap_rights_t *rights, ...);
void cap_rights_set(cap_rights_t *rights, ...);
void cap_rights_clear(cap_rights_t *rights, ...);
bool cap_rights_is_set(const cap_rights_t *rights, ...);
bool cap_rights_is_valid(const cap_rights_t *rights);
void cap_rights_merge(cap_rights_t *dst, const cap_rights_t *src);
void cap_rights_remove(cap_rights_t *dst, const cap_rights_t *src);
bool cap_rights_contains(const cap_rights_t *big, const cap_rights_t *little);
Capability rights to the cap_rights_init(), cap_rights_set(),
cap_rights_clear() and cap_rights_is_set() functions are provided by
separating them with commas, eg:
cap_rights_t rights;
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FSTAT);
There is no need to terminate the list of rights, as those functions are
actually macros that take care of the termination, eg:
#define cap_rights_set(rights, ...) \
__cap_rights_set((rights), __VA_ARGS__, 0ULL)
void __cap_rights_set(cap_rights_t *rights, ...);
Thanks to using one bit as an array index we can assert in those functions that
there are no two rights belonging to different array elements provided
together. For example this is illegal and will be detected, because CAP_LOOKUP
belongs to element 0 and CAP_PDKILL to element 1:
cap_rights_init(&rights, CAP_LOOKUP | CAP_PDKILL);
Providing several rights that belongs to the same array's element this way is
correct, but is not advised. It should only be used for aliases definition.
This commit also breaks compatibility with some existing Capsicum system calls,
but I see no other way to do that. This should be fine as Capsicum is still
experimental and this change is not going to 9.x.
Sponsored by: The FreeBSD Foundation
2013-09-05 00:09:56 +00:00
|
|
|
cap_rights_t rights;
|
2016-07-13 14:37:58 +00:00
|
|
|
struct itimerval it;
|
2010-02-18 16:05:09 +00:00
|
|
|
struct stat sb;
|
|
|
|
struct sockaddr_storage ss;
|
2022-05-11 07:40:39 +00:00
|
|
|
struct bitset *set;
|
2008-02-23 01:01:49 +00:00
|
|
|
|
|
|
|
for (name = buf, namelen = 0;
|
|
|
|
namelen < buflen && name[namelen] != '\0';
|
|
|
|
++namelen)
|
|
|
|
/* nothing */;
|
|
|
|
if (namelen == buflen)
|
|
|
|
goto invalid;
|
|
|
|
if (name[namelen] != '\0')
|
|
|
|
goto invalid;
|
|
|
|
data = buf + namelen + 1;
|
|
|
|
datalen = buflen - namelen - 1;
|
|
|
|
if (datalen == 0)
|
|
|
|
goto invalid;
|
|
|
|
/* sanity check */
|
2011-10-12 21:45:12 +00:00
|
|
|
for (i = 0; i < (int)namelen; ++i)
|
2022-05-11 07:40:39 +00:00
|
|
|
if (!isalpha(name[i]) && name[i] != '_')
|
2008-02-23 01:01:49 +00:00
|
|
|
goto invalid;
|
Change the cap_rights_t type from uint64_t to a structure that we can extend
in the future in a backward compatible (API and ABI) way.
The cap_rights_t represents capability rights. We used to use one bit to
represent one right, but we are running out of spare bits. Currently the new
structure provides place for 114 rights (so 50 more than the previous
cap_rights_t), but it is possible to grow the structure to hold at least 285
rights, although we can make it even larger if 285 rights won't be enough.
The structure definition looks like this:
struct cap_rights {
uint64_t cr_rights[CAP_RIGHTS_VERSION + 2];
};
The initial CAP_RIGHTS_VERSION is 0.
The top two bits in the first element of the cr_rights[] array contain total
number of elements in the array - 2. This means if those two bits are equal to
0, we have 2 array elements.
The top two bits in all remaining array elements should be 0.
The next five bits in all array elements contain array index. Only one bit is
used and bit position in this five-bits range defines array index. This means
there can be at most five array elements in the future.
To define new right the CAPRIGHT() macro must be used. The macro takes two
arguments - an array index and a bit to set, eg.
#define CAP_PDKILL CAPRIGHT(1, 0x0000000000000800ULL)
We still support aliases that combine few rights, but the rights have to belong
to the same array element, eg:
#define CAP_LOOKUP CAPRIGHT(0, 0x0000000000000400ULL)
#define CAP_FCHMOD CAPRIGHT(0, 0x0000000000002000ULL)
#define CAP_FCHMODAT (CAP_FCHMOD | CAP_LOOKUP)
There is new API to manage the new cap_rights_t structure:
cap_rights_t *cap_rights_init(cap_rights_t *rights, ...);
void cap_rights_set(cap_rights_t *rights, ...);
void cap_rights_clear(cap_rights_t *rights, ...);
bool cap_rights_is_set(const cap_rights_t *rights, ...);
bool cap_rights_is_valid(const cap_rights_t *rights);
void cap_rights_merge(cap_rights_t *dst, const cap_rights_t *src);
void cap_rights_remove(cap_rights_t *dst, const cap_rights_t *src);
bool cap_rights_contains(const cap_rights_t *big, const cap_rights_t *little);
Capability rights to the cap_rights_init(), cap_rights_set(),
cap_rights_clear() and cap_rights_is_set() functions are provided by
separating them with commas, eg:
cap_rights_t rights;
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FSTAT);
There is no need to terminate the list of rights, as those functions are
actually macros that take care of the termination, eg:
#define cap_rights_set(rights, ...) \
__cap_rights_set((rights), __VA_ARGS__, 0ULL)
void __cap_rights_set(cap_rights_t *rights, ...);
Thanks to using one bit as an array index we can assert in those functions that
there are no two rights belonging to different array elements provided
together. For example this is illegal and will be detected, because CAP_LOOKUP
belongs to element 0 and CAP_PDKILL to element 1:
cap_rights_init(&rights, CAP_LOOKUP | CAP_PDKILL);
Providing several rights that belongs to the same array's element this way is
correct, but is not advised. It should only be used for aliases definition.
This commit also breaks compatibility with some existing Capsicum system calls,
but I see no other way to do that. This should be fine as Capsicum is still
experimental and this change is not going to 9.x.
Sponsored by: The FreeBSD Foundation
2013-09-05 00:09:56 +00:00
|
|
|
if (strcmp(name, "caprights") == 0) {
|
|
|
|
if (datalen != sizeof(cap_rights_t))
|
|
|
|
goto invalid;
|
|
|
|
memcpy(&rights, data, datalen);
|
|
|
|
ktrcaprights(&rights);
|
2016-07-13 14:37:58 +00:00
|
|
|
} else if (strcmp(name, "itimerval") == 0) {
|
|
|
|
if (datalen != sizeof(struct itimerval))
|
|
|
|
goto invalid;
|
|
|
|
memcpy(&it, data, datalen);
|
|
|
|
ktritimerval(&it);
|
Change the cap_rights_t type from uint64_t to a structure that we can extend
in the future in a backward compatible (API and ABI) way.
The cap_rights_t represents capability rights. We used to use one bit to
represent one right, but we are running out of spare bits. Currently the new
structure provides place for 114 rights (so 50 more than the previous
cap_rights_t), but it is possible to grow the structure to hold at least 285
rights, although we can make it even larger if 285 rights won't be enough.
The structure definition looks like this:
struct cap_rights {
uint64_t cr_rights[CAP_RIGHTS_VERSION + 2];
};
The initial CAP_RIGHTS_VERSION is 0.
The top two bits in the first element of the cr_rights[] array contain total
number of elements in the array - 2. This means if those two bits are equal to
0, we have 2 array elements.
The top two bits in all remaining array elements should be 0.
The next five bits in all array elements contain array index. Only one bit is
used and bit position in this five-bits range defines array index. This means
there can be at most five array elements in the future.
To define new right the CAPRIGHT() macro must be used. The macro takes two
arguments - an array index and a bit to set, eg.
#define CAP_PDKILL CAPRIGHT(1, 0x0000000000000800ULL)
We still support aliases that combine few rights, but the rights have to belong
to the same array element, eg:
#define CAP_LOOKUP CAPRIGHT(0, 0x0000000000000400ULL)
#define CAP_FCHMOD CAPRIGHT(0, 0x0000000000002000ULL)
#define CAP_FCHMODAT (CAP_FCHMOD | CAP_LOOKUP)
There is new API to manage the new cap_rights_t structure:
cap_rights_t *cap_rights_init(cap_rights_t *rights, ...);
void cap_rights_set(cap_rights_t *rights, ...);
void cap_rights_clear(cap_rights_t *rights, ...);
bool cap_rights_is_set(const cap_rights_t *rights, ...);
bool cap_rights_is_valid(const cap_rights_t *rights);
void cap_rights_merge(cap_rights_t *dst, const cap_rights_t *src);
void cap_rights_remove(cap_rights_t *dst, const cap_rights_t *src);
bool cap_rights_contains(const cap_rights_t *big, const cap_rights_t *little);
Capability rights to the cap_rights_init(), cap_rights_set(),
cap_rights_clear() and cap_rights_is_set() functions are provided by
separating them with commas, eg:
cap_rights_t rights;
cap_rights_init(&rights, CAP_READ, CAP_WRITE, CAP_FSTAT);
There is no need to terminate the list of rights, as those functions are
actually macros that take care of the termination, eg:
#define cap_rights_set(rights, ...) \
__cap_rights_set((rights), __VA_ARGS__, 0ULL)
void __cap_rights_set(cap_rights_t *rights, ...);
Thanks to using one bit as an array index we can assert in those functions that
there are no two rights belonging to different array elements provided
together. For example this is illegal and will be detected, because CAP_LOOKUP
belongs to element 0 and CAP_PDKILL to element 1:
cap_rights_init(&rights, CAP_LOOKUP | CAP_PDKILL);
Providing several rights that belongs to the same array's element this way is
correct, but is not advised. It should only be used for aliases definition.
This commit also breaks compatibility with some existing Capsicum system calls,
but I see no other way to do that. This should be fine as Capsicum is still
experimental and this change is not going to 9.x.
Sponsored by: The FreeBSD Foundation
2013-09-05 00:09:56 +00:00
|
|
|
} else if (strcmp(name, "stat") == 0) {
|
2008-02-23 01:01:49 +00:00
|
|
|
if (datalen != sizeof(struct stat))
|
|
|
|
goto invalid;
|
2010-02-18 16:05:09 +00:00
|
|
|
memcpy(&sb, data, datalen);
|
|
|
|
ktrstat(&sb);
|
2008-02-23 01:01:49 +00:00
|
|
|
} else if (strcmp(name, "sockaddr") == 0) {
|
2010-02-18 16:05:09 +00:00
|
|
|
if (datalen > sizeof(ss))
|
|
|
|
goto invalid;
|
|
|
|
memcpy(&ss, data, datalen);
|
2013-02-12 19:10:54 +00:00
|
|
|
if (datalen != ss.ss_len)
|
2008-02-23 01:01:49 +00:00
|
|
|
goto invalid;
|
2010-02-18 16:05:09 +00:00
|
|
|
ktrsockaddr((struct sockaddr *)&ss);
|
2022-05-11 07:40:39 +00:00
|
|
|
} else if (strcmp(name, "cpuset_t") == 0) {
|
|
|
|
if (datalen < 1)
|
|
|
|
goto invalid;
|
|
|
|
set = malloc(datalen);
|
|
|
|
if (set == NULL)
|
|
|
|
errx(1, "%s", strerror(ENOMEM));
|
|
|
|
memcpy(set, data, datalen);
|
|
|
|
ktrbitset(name, set, datalen);
|
|
|
|
free(set);
|
2008-02-23 01:01:49 +00:00
|
|
|
} else {
|
2022-06-22 11:15:20 +00:00
|
|
|
#ifdef SYSDECODE_HAVE_LINUX
|
|
|
|
if (ktrstruct_linux(name, data, datalen) == false)
|
|
|
|
#endif
|
|
|
|
printf("unknown structure\n");
|
2008-02-23 01:01:49 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
invalid:
|
|
|
|
printf("invalid record\n");
|
|
|
|
}
|
|
|
|
|
2011-10-11 20:37:10 +00:00
|
|
|
void
|
|
|
|
ktrcapfail(struct ktr_cap_fail *ktr)
|
|
|
|
{
|
2011-10-18 07:28:58 +00:00
|
|
|
switch (ktr->cap_type) {
|
|
|
|
case CAPFAIL_NOTCAPABLE:
|
|
|
|
/* operation on fd with insufficient capabilities */
|
|
|
|
printf("operation requires ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
sysdecode_cap_rights(stdout, &ktr->cap_needed);
|
2014-02-23 22:13:16 +00:00
|
|
|
printf(", descriptor holds ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
sysdecode_cap_rights(stdout, &ktr->cap_held);
|
2011-10-18 07:28:58 +00:00
|
|
|
break;
|
|
|
|
case CAPFAIL_INCREASE:
|
|
|
|
/* requested more capabilities than fd already has */
|
|
|
|
printf("attempt to increase capabilities from ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
sysdecode_cap_rights(stdout, &ktr->cap_held);
|
2011-10-18 09:39:41 +00:00
|
|
|
printf(" to ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
sysdecode_cap_rights(stdout, &ktr->cap_needed);
|
2011-10-18 07:28:58 +00:00
|
|
|
break;
|
|
|
|
case CAPFAIL_SYSCALL:
|
|
|
|
/* called restricted syscall */
|
|
|
|
printf("disallowed system call");
|
|
|
|
break;
|
|
|
|
case CAPFAIL_LOOKUP:
|
2019-02-18 03:49:16 +00:00
|
|
|
/* absolute or AT_FDCWD path, ".." path, etc. */
|
2011-10-18 07:28:58 +00:00
|
|
|
printf("restricted VFS lookup");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("unknown capability failure: ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
sysdecode_cap_rights(stdout, &ktr->cap_needed);
|
2011-10-18 07:28:58 +00:00
|
|
|
printf(" ");
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
sysdecode_cap_rights(stdout, &ktr->cap_held);
|
2011-10-18 07:28:58 +00:00
|
|
|
break;
|
|
|
|
}
|
2012-04-05 17:13:14 +00:00
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ktrfault(struct ktr_fault *ktr)
|
|
|
|
{
|
|
|
|
|
2015-01-06 18:53:09 +00:00
|
|
|
printf("0x%jx ", (uintmax_t)ktr->vaddr);
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
print_mask_arg(sysdecode_vmprot, ktr->type);
|
2012-04-05 17:13:14 +00:00
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ktrfaultend(struct ktr_faultend *ktr)
|
|
|
|
{
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
const char *str;
|
2012-04-05 17:13:14 +00:00
|
|
|
|
Move mksubr from kdump into libsysdecode.
Restructure this script so that it generates a header of tables instead
of a source file. The tables are included in a flags.c source file which
provides functions to decode various system call arguments.
For functions that decode an enumeration, the function returns a pointer
to a string for known values and NULL for unknown values.
For functions that do more complex decoding (typically of a bitmask), the
function accepts a pointer to a FILE object (open_memstream() can be used
as a string builder) to which decoded values are written. If the
function operates on a bitmask, the function returns true if any bits
were decoded or false if the entire value was valid. Additionally, the
third argument accepts a pointer to a value to which any undecoded bits
are stored. This pointer can be NULL if the caller doesn't care about
remaining bits.
Convert kdump over to using decoder functions from libsysdecode instead of
mksubr. truss also uses decoders from libsysdecode instead of private
lookup tables, though lookup tables for objects not decoded by kdump remain
in truss for now. Eventually most of these tables should move into
libsysdecode as the automated table generation approach from mksubr is
less stale than the static tables in truss.
Some changes have been made to truss and kdump output:
- The flags passed to open() are now properly decoded in that one of
O_RDONLY, O_RDWR, O_WRONLY, or O_EXEC is always included in a decoded
mask.
- Optional arguments to open(), openat(), and fcntl() are only printed
in kdump if they exist (e.g. the mode is only printed for open() if
O_CREAT is set in the flags).
- Print argument to F_GETLK/SETLK/SETLKW in kdump as a pointer, not int.
- Include all procctl() commands.
- Correctly decode pipe2() flags in truss by not assuming full
open()-like flags with O_RDONLY, etc.
- Decode file flags passed to *chflags() as file flags (UF_* and SF_*)
rather than as a file mode.
- Fix decoding of quotactl() commands by splitting out the two command
components instead of assuming the raw command value matches the
primary command component.
In addition, truss and kdump now build without triggering any warnings.
All of the sysdecode manpages now include the required headers in the
synopsis.
Reviewed by: kib (several older versions), wblock (manpages)
MFC after: 2 months
Differential Revision: https://reviews.freebsd.org/D7847
2016-10-17 22:37:07 +00:00
|
|
|
str = sysdecode_vmresult(ktr->result);
|
|
|
|
if (str != NULL)
|
|
|
|
printf("%s", str);
|
|
|
|
else
|
|
|
|
printf("<invalid=%d>", ktr->result);
|
2012-04-05 17:13:14 +00:00
|
|
|
printf("\n");
|
2011-10-11 20:37:10 +00:00
|
|
|
}
|
|
|
|
|
2017-11-25 04:49:12 +00:00
|
|
|
void
|
|
|
|
ktrkevent(struct kevent *kev)
|
|
|
|
{
|
|
|
|
|
|
|
|
printf("{ ident=");
|
|
|
|
switch (kev->filter) {
|
|
|
|
case EVFILT_READ:
|
|
|
|
case EVFILT_WRITE:
|
|
|
|
case EVFILT_VNODE:
|
|
|
|
case EVFILT_PROC:
|
|
|
|
case EVFILT_TIMER:
|
|
|
|
case EVFILT_PROCDESC:
|
|
|
|
case EVFILT_EMPTY:
|
|
|
|
printf("%ju", (uintmax_t)kev->ident);
|
|
|
|
break;
|
|
|
|
case EVFILT_SIGNAL:
|
|
|
|
print_signal(kev->ident);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("%p", (void *)kev->ident);
|
|
|
|
}
|
|
|
|
printf(", filter=");
|
|
|
|
print_integer_arg(sysdecode_kevent_filter, kev->filter);
|
|
|
|
printf(", flags=");
|
|
|
|
print_mask_arg0(sysdecode_kevent_flags, kev->flags);
|
|
|
|
printf(", fflags=");
|
|
|
|
sysdecode_kevent_fflags(stdout, kev->filter, kev->fflags,
|
|
|
|
decimal ? 10 : 16);
|
|
|
|
printf(", data=%#jx, udata=%p }", (uintmax_t)kev->data, kev->udata);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ktrstructarray(struct ktr_struct_array *ksa, size_t buflen)
|
|
|
|
{
|
|
|
|
struct kevent kev;
|
|
|
|
char *name, *data;
|
|
|
|
size_t namelen, datalen;
|
|
|
|
int i;
|
|
|
|
bool first;
|
|
|
|
|
|
|
|
buflen -= sizeof(*ksa);
|
|
|
|
for (name = (char *)(ksa + 1), namelen = 0;
|
|
|
|
namelen < buflen && name[namelen] != '\0';
|
|
|
|
++namelen)
|
|
|
|
/* nothing */;
|
|
|
|
if (namelen == buflen)
|
|
|
|
goto invalid;
|
|
|
|
if (name[namelen] != '\0')
|
|
|
|
goto invalid;
|
|
|
|
/* sanity check */
|
|
|
|
for (i = 0; i < (int)namelen; ++i)
|
|
|
|
if (!isalnum(name[i]) && name[i] != '_')
|
|
|
|
goto invalid;
|
|
|
|
data = name + namelen + 1;
|
|
|
|
datalen = buflen - namelen - 1;
|
|
|
|
printf("struct %s[] = { ", name);
|
|
|
|
first = true;
|
|
|
|
for (; datalen >= ksa->struct_size;
|
|
|
|
data += ksa->struct_size, datalen -= ksa->struct_size) {
|
|
|
|
if (!first)
|
|
|
|
printf("\n ");
|
|
|
|
else
|
|
|
|
first = false;
|
|
|
|
if (strcmp(name, "kevent") == 0) {
|
|
|
|
if (ksa->struct_size != sizeof(kev))
|
|
|
|
goto bad_size;
|
|
|
|
memcpy(&kev, data, sizeof(kev));
|
|
|
|
ktrkevent(&kev);
|
2021-11-15 18:34:27 +00:00
|
|
|
} else if (strcmp(name, "freebsd11_kevent") == 0) {
|
|
|
|
struct freebsd11_kevent kev11;
|
2017-11-25 04:49:12 +00:00
|
|
|
|
|
|
|
if (ksa->struct_size != sizeof(kev11))
|
|
|
|
goto bad_size;
|
|
|
|
memcpy(&kev11, data, sizeof(kev11));
|
|
|
|
memset(&kev, 0, sizeof(kev));
|
|
|
|
kev.ident = kev11.ident;
|
|
|
|
kev.filter = kev11.filter;
|
|
|
|
kev.flags = kev11.flags;
|
|
|
|
kev.fflags = kev11.fflags;
|
|
|
|
kev.data = kev11.data;
|
|
|
|
kev.udata = kev11.udata;
|
|
|
|
ktrkevent(&kev);
|
|
|
|
#ifdef _WANT_KEVENT32
|
|
|
|
} else if (strcmp(name, "kevent32") == 0) {
|
|
|
|
struct kevent32 kev32;
|
|
|
|
|
|
|
|
if (ksa->struct_size != sizeof(kev32))
|
|
|
|
goto bad_size;
|
|
|
|
memcpy(&kev32, data, sizeof(kev32));
|
|
|
|
memset(&kev, 0, sizeof(kev));
|
|
|
|
kev.ident = kev32.ident;
|
|
|
|
kev.filter = kev32.filter;
|
|
|
|
kev.flags = kev32.flags;
|
|
|
|
kev.fflags = kev32.fflags;
|
|
|
|
#if BYTE_ORDER == BIG_ENDIAN
|
|
|
|
kev.data = kev32.data2 | ((int64_t)kev32.data1 << 32);
|
|
|
|
#else
|
|
|
|
kev.data = kev32.data1 | ((int64_t)kev32.data2 << 32);
|
|
|
|
#endif
|
|
|
|
kev.udata = (void *)(uintptr_t)kev32.udata;
|
|
|
|
ktrkevent(&kev);
|
2021-11-15 18:34:27 +00:00
|
|
|
} else if (strcmp(name, "freebsd11_kevent32") == 0) {
|
|
|
|
struct freebsd11_kevent32 kev32;
|
2017-11-25 04:49:12 +00:00
|
|
|
|
|
|
|
if (ksa->struct_size != sizeof(kev32))
|
|
|
|
goto bad_size;
|
|
|
|
memcpy(&kev32, data, sizeof(kev32));
|
|
|
|
memset(&kev, 0, sizeof(kev));
|
|
|
|
kev.ident = kev32.ident;
|
|
|
|
kev.filter = kev32.filter;
|
|
|
|
kev.flags = kev32.flags;
|
|
|
|
kev.fflags = kev32.fflags;
|
|
|
|
kev.data = kev32.data;
|
|
|
|
kev.udata = (void *)(uintptr_t)kev32.udata;
|
|
|
|
ktrkevent(&kev);
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
printf("<unknown structure> }\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
printf(" }\n");
|
|
|
|
return;
|
|
|
|
invalid:
|
|
|
|
printf("invalid record\n");
|
|
|
|
return;
|
|
|
|
bad_size:
|
|
|
|
printf("<bad size> }\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-07-28 16:05:07 +00:00
|
|
|
void
|
|
|
|
usage(void)
|
1994-05-27 12:33:43 +00:00
|
|
|
{
|
2014-03-28 16:11:20 +00:00
|
|
|
fprintf(stderr, "usage: kdump [-dEnlHRrSsTA] [-f trfile] "
|
2008-04-02 09:41:29 +00:00
|
|
|
"[-m maxdata] [-p pid] [-t trstr]\n");
|
1994-05-27 12:33:43 +00:00
|
|
|
exit(1);
|
|
|
|
}
|