flags.c revision 324398 
1/*
2 * Copyright (c) 2006 "David Kirchner" <dpk@dpk.net>. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26#include <sys/cdefs.h>
27__FBSDID("$FreeBSD: stable/11/lib/libsysdecode/flags.c 324398 2017-10-07 20:20:01Z emaste $");
28
29#define L2CAP_SOCKET_CHECKED
30
31#include <sys/types.h>
32#include <sys/acl.h>
33#include <sys/capsicum.h>
34#include <sys/extattr.h>
35#include <sys/linker.h>
36#include <sys/mman.h>
37#include <sys/mount.h>
38#include <sys/procctl.h>
39#include <sys/ptrace.h>
40#include <sys/reboot.h>
41#include <sys/resource.h>
42#include <sys/rtprio.h>
43#include <sys/sem.h>
44#include <sys/shm.h>
45#include <sys/socket.h>
46#include <sys/stat.h>
47#include <sys/thr.h>
48#include <sys/umtx.h>
49#include <netinet/in.h>
50#include <netinet/sctp.h>
51#include <netinet/tcp.h>
52#include <netinet/udp.h>
53#include <netinet/udplite.h>
54#include <nfsserver/nfs.h>
55#include <ufs/ufs/quota.h>
56#include <vm/vm.h>
57#include <vm/vm_param.h>
58#include <aio.h>
59#include <fcntl.h>
60#include <sched.h>
61#include <stdbool.h>
62#include <stdio.h>
63#include <stdlib.h>
64#include <strings.h>
65#include <sysdecode.h>
66#include <unistd.h>
67#include <sys/bitstring.h>
68#include <netgraph/bluetooth/include/ng_hci.h>
69#include <netgraph/bluetooth/include/ng_l2cap.h>
70#include <netgraph/bluetooth/include/ng_btsocket.h>
71
72/*
73 * This is taken from the xlat tables originally in truss which were
74 * in turn taken from strace.
75 */
76struct name_table {
77	uintmax_t val;
78	const char *str;
79};
80
81#define	X(a)	{ a, #a },
82#define	XEND	{ 0, NULL }
83
84#define	TABLE_START(n)	static struct name_table n[] = {
85#define	TABLE_ENTRY	X
86#define	TABLE_END	XEND };
87
88#include "tables.h"
89
90#undef TABLE_START
91#undef TABLE_ENTRY
92#undef TABLE_END
93
94/*
95 * These are simple support macros. print_or utilizes a variable
96 * defined in the calling function to track whether or not it should
97 * print a logical-OR character ('|') before a string. if_print_or
98 * simply handles the necessary "if" statement used in many lines
99 * of this file.
100 */
101#define print_or(fp,str,orflag) do {                     \
102	if (orflag) fputc(fp, '|'); else orflag = true;  \
103	fprintf(fp, str); }                              \
104	while (0)
105#define if_print_or(fp,i,flag,orflag) do {         \
106	if ((i & flag) == flag)                    \
107	print_or(fp,#flag,orflag); }               \
108	while (0)
109
110static const char *
111lookup_value(struct name_table *table, uintmax_t val)
112{
113
114	for (; table->str != NULL; table++)
115		if (table->val == val)
116			return (table->str);
117	return (NULL);
118}
119
120/*
121 * Used when the value maps to a bitmask of #definition values in the
122 * table.  This is a helper routine which outputs a symbolic mask of
123 * matched masks.  Multiple masks are separated by a pipe ('|').
124 * The value is modified on return to only hold unmatched bits.
125 */
126static void
127print_mask_part(FILE *fp, struct name_table *table, uintmax_t *valp,
128    bool *printed)
129{
130	uintmax_t rem;
131
132	rem = *valp;
133	for (; table->str != NULL; table++) {
134		if ((table->val & rem) == table->val) {
135			/*
136			 * Only print a zero mask if the raw value is
137			 * zero.
138			 */
139			if (table->val == 0 && *valp != 0)
140				continue;
141			fprintf(fp, "%s%s", *printed ? "|" : "", table->str);
142			*printed = true;
143			rem &= ~table->val;
144		}
145	}
146
147	*valp = rem;
148}
149
150/*
151 * Used when the value maps to a bitmask of #definition values in the
152 * table.  The return value is true if something was printed.  If
153 * rem is not NULL, *rem holds any bits not decoded if something was
154 * printed.  If nothing was printed and rem is not NULL, *rem holds
155 * the original value.
156 */
157static bool
158print_mask_int(FILE *fp, struct name_table *table, int ival, int *rem)
159{
160	uintmax_t val;
161	bool printed;
162
163	printed = false;
164	val = (unsigned)ival;
165	print_mask_part(fp, table, &val, &printed);
166	if (rem != NULL)
167		*rem = val;
168	return (printed);
169}
170
171/*
172 * Used for a mask of optional flags where a value of 0 is valid.
173 */
174static bool
175print_mask_0(FILE *fp, struct name_table *table, int val, int *rem)
176{
177
178	if (val == 0) {
179		fputs("0", fp);
180		if (rem != NULL)
181			*rem = 0;
182		return (true);
183	}
184	return (print_mask_int(fp, table, val, rem));
185}
186
187/*
188 * Like print_mask_0 but for a unsigned long instead of an int.
189 */
190static bool
191print_mask_0ul(FILE *fp, struct name_table *table, u_long lval, u_long *rem)
192{
193	uintmax_t val;
194	bool printed;
195
196	if (lval == 0) {
197		fputs("0", fp);
198		if (rem != NULL)
199			*rem = 0;
200		return (true);
201	}
202
203	printed = false;
204	val = lval;
205	print_mask_part(fp, table, &val, &printed);
206	if (rem != NULL)
207		*rem = val;
208	return (printed);
209}
210
211static void
212print_integer(FILE *fp, int val, int base)
213{
214
215	switch (base) {
216	case 8:
217		fprintf(fp, "0%o", val);
218		break;
219	case 10:
220		fprintf(fp, "%d", val);
221		break;
222	case 16:
223		fprintf(fp, "0x%x", val);
224		break;
225	default:
226		abort2("bad base", 0, NULL);
227		break;
228	}
229}
230
231static bool
232print_value(FILE *fp, struct name_table *table, uintmax_t val)
233{
234	const char *str;
235
236	str = lookup_value(table, val);
237	if (str != NULL) {
238		fputs(str, fp);
239		return (true);
240	}
241	return (false);
242}
243
244const char *
245sysdecode_atfd(int fd)
246{
247
248	if (fd == AT_FDCWD)
249		return ("AT_FDCWD");
250	return (NULL);
251}
252
253static struct name_table semctlops[] = {
254	X(GETNCNT) X(GETPID) X(GETVAL) X(GETALL) X(GETZCNT) X(SETVAL) X(SETALL)
255	X(IPC_RMID) X(IPC_SET) X(IPC_STAT) XEND
256};
257
258const char *
259sysdecode_semctl_cmd(int cmd)
260{
261
262	return (lookup_value(semctlops, cmd));
263}
264
265static struct name_table shmctlops[] = {
266	X(IPC_RMID) X(IPC_SET) X(IPC_STAT) XEND
267};
268
269const char *
270sysdecode_shmctl_cmd(int cmd)
271{
272
273	return (lookup_value(shmctlops, cmd));
274}
275
276const char *
277sysdecode_msgctl_cmd(int cmd)
278{
279
280	return (sysdecode_shmctl_cmd(cmd));
281}
282
283static struct name_table semgetflags[] = {
284	X(IPC_CREAT) X(IPC_EXCL) X(SEM_R) X(SEM_A) X((SEM_R>>3)) X((SEM_A>>3))
285	X((SEM_R>>6)) X((SEM_A>>6)) XEND
286};
287
288bool
289sysdecode_semget_flags(FILE *fp, int flag, int *rem)
290{
291
292	return (print_mask_int(fp, semgetflags, flag, rem));
293}
294
295static struct name_table idtypes[] = {
296	X(P_PID) X(P_PPID) X(P_PGID) X(P_SID) X(P_CID) X(P_UID) X(P_GID)
297	X(P_ALL) X(P_LWPID) X(P_TASKID) X(P_PROJID) X(P_POOLID) X(P_JAILID)
298	X(P_CTID) X(P_CPUID) X(P_PSETID) XEND
299};
300
301/* XXX: idtype is really an idtype_t */
302const char *
303sysdecode_idtype(int idtype)
304{
305
306	return (lookup_value(idtypes, idtype));
307}
308
309/*
310 * [g|s]etsockopt's level argument can either be SOL_SOCKET or a
311 * protocol-specific value.
312 */
313const char *
314sysdecode_sockopt_level(int level)
315{
316	const char *str;
317
318	if (level == SOL_SOCKET)
319		return ("SOL_SOCKET");
320
321	/* SOL_* constants for Bluetooth sockets. */
322	str = lookup_value(ngbtsolevel, level);
323	if (str != NULL)
324		return (str);
325
326	/*
327	 * IP and Infiniband sockets use IP protocols as levels.  Not all
328	 * protocols are valid but it is simpler to just allow all of them.
329	 *
330	 * XXX: IPPROTO_IP == 0, but UNIX domain sockets use a level of 0
331	 * for private options.
332	 */
333	str = sysdecode_ipproto(level);
334	if (str != NULL)
335		return (str);
336
337	return (NULL);
338}
339
340bool
341sysdecode_vmprot(FILE *fp, int type, int *rem)
342{
343
344	return (print_mask_int(fp, vmprot, type, rem));
345}
346
347static struct name_table sockflags[] = {
348	X(SOCK_CLOEXEC) X(SOCK_NONBLOCK) XEND
349};
350
351bool
352sysdecode_socket_type(FILE *fp, int type, int *rem)
353{
354	const char *str;
355	uintmax_t val;
356	bool printed;
357
358	str = lookup_value(socktype, type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK));
359	if (str != NULL) {
360		fputs(str, fp);
361		*rem = 0;
362		printed = true;
363	} else {
364		*rem = type & ~(SOCK_CLOEXEC | SOCK_NONBLOCK);
365		printed = false;
366	}
367	val = type & (SOCK_CLOEXEC | SOCK_NONBLOCK);
368	print_mask_part(fp, sockflags, &val, &printed);
369	return (printed);
370}
371
372bool
373sysdecode_access_mode(FILE *fp, int mode, int *rem)
374{
375
376	return (print_mask_int(fp, accessmode, mode, rem));
377}
378
379/* XXX: 'type' is really an acl_type_t. */
380const char *
381sysdecode_acltype(int type)
382{
383
384	return (lookup_value(acltype, type));
385}
386
387bool
388sysdecode_cap_fcntlrights(FILE *fp, uint32_t rights, uint32_t *rem)
389{
390
391	return (print_mask_int(fp, capfcntl, rights, rem));
392}
393
394const char *
395sysdecode_extattrnamespace(int namespace)
396{
397
398	return (lookup_value(extattrns, namespace));
399}
400
401const char *
402sysdecode_fadvice(int advice)
403{
404
405	return (lookup_value(fadvisebehav, advice));
406}
407
408bool
409sysdecode_open_flags(FILE *fp, int flags, int *rem)
410{
411	bool printed;
412	int mode;
413	uintmax_t val;
414
415	mode = flags & O_ACCMODE;
416	flags &= ~O_ACCMODE;
417	switch (mode) {
418	case O_RDONLY:
419		if (flags & O_EXEC) {
420			flags &= ~O_EXEC;
421			fputs("O_EXEC", fp);
422		} else
423			fputs("O_RDONLY", fp);
424		printed = true;
425		mode = 0;
426		break;
427	case O_WRONLY:
428		fputs("O_WRONLY", fp);
429		printed = true;
430		mode = 0;
431		break;
432	case O_RDWR:
433		fputs("O_RDWR", fp);
434		printed = true;
435		mode = 0;
436		break;
437	default:
438		printed = false;
439	}
440	val = (unsigned)flags;
441	print_mask_part(fp, openflags, &val, &printed);
442	if (rem != NULL)
443		*rem = val | mode;
444	return (printed);
445}
446
447bool
448sysdecode_fcntl_fileflags(FILE *fp, int flags, int *rem)
449{
450	bool printed;
451	int oflags;
452
453	/*
454	 * The file flags used with F_GETFL/F_SETFL mostly match the
455	 * flags passed to open(2).  However, a few open-only flag
456	 * bits have been repurposed for fcntl-only flags.
457	 */
458	oflags = flags & ~(O_NOFOLLOW | FRDAHEAD);
459	printed = sysdecode_open_flags(fp, oflags, rem);
460	if (flags & O_NOFOLLOW) {
461		fprintf(fp, "%sFPOIXSHM", printed ? "|" : "");
462		printed = true;
463	}
464	if (flags & FRDAHEAD) {
465		fprintf(fp, "%sFRDAHEAD", printed ? "|" : "");
466		printed = true;
467	}
468	return (printed);
469}
470
471bool
472sysdecode_flock_operation(FILE *fp, int operation, int *rem)
473{
474
475	return (print_mask_int(fp, flockops, operation, rem));
476}
477
478static struct name_table getfsstatmode[] = {
479	X(MNT_WAIT) X(MNT_NOWAIT) XEND
480};
481
482const char *
483sysdecode_getfsstat_mode(int mode)
484{
485
486	return (lookup_value(getfsstatmode, mode));
487}
488
489const char *
490sysdecode_kldsym_cmd(int cmd)
491{
492
493	return (lookup_value(kldsymcmd, cmd));
494}
495
496const char *
497sysdecode_kldunload_flags(int flags)
498{
499
500	return (lookup_value(kldunloadfflags, flags));
501}
502
503const char *
504sysdecode_lio_listio_mode(int mode)
505{
506
507	return (lookup_value(lio_listiomodes, mode));
508}
509
510const char *
511sysdecode_madvice(int advice)
512{
513
514	return (lookup_value(madvisebehav, advice));
515}
516
517const char *
518sysdecode_minherit_inherit(int inherit)
519{
520
521	return (lookup_value(minheritflags, inherit));
522}
523
524bool
525sysdecode_mlockall_flags(FILE *fp, int flags, int *rem)
526{
527
528	return (print_mask_int(fp, mlockallflags, flags, rem));
529}
530
531bool
532sysdecode_mmap_prot(FILE *fp, int prot, int *rem)
533{
534
535	return (print_mask_int(fp, mmapprot, prot, rem));
536}
537
538bool
539sysdecode_fileflags(FILE *fp, fflags_t flags, fflags_t *rem)
540{
541
542	return (print_mask_0(fp, fileflags, flags, rem));
543}
544
545bool
546sysdecode_filemode(FILE *fp, int mode, int *rem)
547{
548
549	return (print_mask_0(fp, filemode, mode, rem));
550}
551
552bool
553sysdecode_mount_flags(FILE *fp, int flags, int *rem)
554{
555
556	return (print_mask_int(fp, mountflags, flags, rem));
557}
558
559bool
560sysdecode_msync_flags(FILE *fp, int flags, int *rem)
561{
562
563	return (print_mask_int(fp, msyncflags, flags, rem));
564}
565
566const char *
567sysdecode_nfssvc_flags(int flags)
568{
569
570	return (lookup_value(nfssvcflags, flags));
571}
572
573static struct name_table pipe2flags[] = {
574	X(O_CLOEXEC) X(O_NONBLOCK) XEND
575};
576
577bool
578sysdecode_pipe2_flags(FILE *fp, int flags, int *rem)
579{
580
581	return (print_mask_0(fp, pipe2flags, flags, rem));
582}
583
584const char *
585sysdecode_prio_which(int which)
586{
587
588	return (lookup_value(prio, which));
589}
590
591const char *
592sysdecode_procctl_cmd(int cmd)
593{
594
595	return (lookup_value(procctlcmd, cmd));
596}
597
598const char *
599sysdecode_ptrace_request(int request)
600{
601
602	return (lookup_value(ptraceop, request));
603}
604
605static struct name_table quotatypes[] = {
606	X(GRPQUOTA) X(USRQUOTA) XEND
607};
608
609bool
610sysdecode_quotactl_cmd(FILE *fp, int cmd)
611{
612	const char *primary, *type;
613
614	primary = lookup_value(quotactlcmds, cmd >> SUBCMDSHIFT);
615	if (primary == NULL)
616		return (false);
617	fprintf(fp, "QCMD(%s,", primary);
618	type = lookup_value(quotatypes, cmd & SUBCMDMASK);
619	if (type != NULL)
620		fprintf(fp, "%s", type);
621	else
622		fprintf(fp, "%#x", cmd & SUBCMDMASK);
623	fprintf(fp, ")");
624	return (true);
625}
626
627bool
628sysdecode_reboot_howto(FILE *fp, int howto, int *rem)
629{
630
631	return (print_mask_int(fp, rebootopt, howto, rem));
632}
633
634bool
635sysdecode_rfork_flags(FILE *fp, int flags, int *rem)
636{
637
638	return (print_mask_int(fp, rforkflags, flags, rem));
639}
640
641const char *
642sysdecode_rlimit(int resource)
643{
644
645	return (lookup_value(rlimit, resource));
646}
647
648const char *
649sysdecode_scheduler_policy(int policy)
650{
651
652	return (lookup_value(schedpolicy, policy));
653}
654
655bool
656sysdecode_sendfile_flags(FILE *fp, int flags, int *rem)
657{
658
659	return (print_mask_int(fp, sendfileflags, flags, rem));
660}
661
662bool
663sysdecode_shmat_flags(FILE *fp, int flags, int *rem)
664{
665
666	return (print_mask_int(fp, shmatflags, flags, rem));
667}
668
669const char *
670sysdecode_shutdown_how(int how)
671{
672
673	return (lookup_value(shutdownhow, how));
674}
675
676const char *
677sysdecode_sigbus_code(int si_code)
678{
679
680	return (lookup_value(sigbuscode, si_code));
681}
682
683const char *
684sysdecode_sigchld_code(int si_code)
685{
686
687	return (lookup_value(sigchldcode, si_code));
688}
689
690const char *
691sysdecode_sigfpe_code(int si_code)
692{
693
694	return (lookup_value(sigfpecode, si_code));
695}
696
697const char *
698sysdecode_sigill_code(int si_code)
699{
700
701	return (lookup_value(sigillcode, si_code));
702}
703
704const char *
705sysdecode_sigsegv_code(int si_code)
706{
707
708	return (lookup_value(sigsegvcode, si_code));
709}
710
711const char *
712sysdecode_sigtrap_code(int si_code)
713{
714
715	return (lookup_value(sigtrapcode, si_code));
716}
717
718const char *
719sysdecode_sigprocmask_how(int how)
720{
721
722	return (lookup_value(sigprocmaskhow, how));
723}
724
725const char *
726sysdecode_socketdomain(int domain)
727{
728
729	return (lookup_value(sockdomain, domain));
730}
731
732const char *
733sysdecode_socket_protocol(int domain, int protocol)
734{
735
736	switch (domain) {
737	case PF_INET:
738	case PF_INET6:
739		return (lookup_value(sockipproto, protocol));
740	default:
741		return (NULL);
742	}
743}
744
745const char *
746sysdecode_sockaddr_family(int sa_family)
747{
748
749	return (lookup_value(sockfamily, sa_family));
750}
751
752const char *
753sysdecode_ipproto(int protocol)
754{
755
756	return (lookup_value(sockipproto, protocol));
757}
758
759const char *
760sysdecode_sockopt_name(int level, int optname)
761{
762
763	if (level == SOL_SOCKET)
764		return (lookup_value(sockopt, optname));
765	if (level == IPPROTO_IP)
766		/* XXX: UNIX domain socket options use a level of 0 also. */
767		return (lookup_value(sockoptip, optname));
768	if (level == IPPROTO_IPV6)
769		return (lookup_value(sockoptipv6, optname));
770	if (level == IPPROTO_SCTP)
771		return (lookup_value(sockoptsctp, optname));
772	if (level == IPPROTO_TCP)
773		return (lookup_value(sockopttcp, optname));
774	if (level == IPPROTO_UDP)
775		return (lookup_value(sockoptudp, optname));
776	if (level == IPPROTO_UDPLITE)
777		return (lookup_value(sockoptudplite, optname));
778	return (NULL);
779}
780
781bool
782sysdecode_thr_create_flags(FILE *fp, int flags, int *rem)
783{
784
785	return (print_mask_int(fp, thrcreateflags, flags, rem));
786}
787
788const char *
789sysdecode_umtx_op(int op)
790{
791
792	return (lookup_value(umtxop, op));
793}
794
795const char *
796sysdecode_vmresult(int result)
797{
798
799	return (lookup_value(vmresult, result));
800}
801
802bool
803sysdecode_wait4_options(FILE *fp, int options, int *rem)
804{
805	bool printed;
806	int opt6;
807
808	/* A flags value of 0 is normal. */
809	if (options == 0) {
810		fputs("0", fp);
811		if (rem != NULL)
812			*rem = 0;
813		return (true);
814	}
815
816	/*
817	 * These flags are implicit and aren't valid flags for wait4()
818	 * directly (though they don't fail with EINVAL).
819	 */
820	opt6 = options & (WEXITED | WTRAPPED);
821	options &= ~opt6;
822	printed = print_mask_int(fp, wait6opt, options, rem);
823	if (rem != NULL)
824		*rem |= opt6;
825	return (printed);
826}
827
828bool
829sysdecode_wait6_options(FILE *fp, int options, int *rem)
830{
831
832	return (print_mask_int(fp, wait6opt, options, rem));
833}
834
835const char *
836sysdecode_whence(int whence)
837{
838
839	return (lookup_value(seekwhence, whence));
840}
841
842const char *
843sysdecode_fcntl_cmd(int cmd)
844{
845
846	return (lookup_value(fcntlcmd, cmd));
847}
848
849static struct name_table fcntl_fd_arg[] = {
850	X(FD_CLOEXEC) X(0) XEND
851};
852
853bool
854sysdecode_fcntl_arg_p(int cmd)
855{
856
857	switch (cmd) {
858	case F_GETFD:
859	case F_GETFL:
860	case F_GETOWN:
861		return (false);
862	default:
863		return (true);
864	}
865}
866
867void
868sysdecode_fcntl_arg(FILE *fp, int cmd, uintptr_t arg, int base)
869{
870	int rem;
871
872	switch (cmd) {
873	case F_SETFD:
874		if (!print_value(fp, fcntl_fd_arg, arg))
875		    print_integer(fp, arg, base);
876		break;
877	case F_SETFL:
878		if (!sysdecode_fcntl_fileflags(fp, arg, &rem))
879			fprintf(fp, "%#x", rem);
880		else if (rem != 0)
881			fprintf(fp, "|%#x", rem);
882		break;
883	case F_GETLK:
884	case F_SETLK:
885	case F_SETLKW:
886		fprintf(fp, "%p", (void *)arg);
887		break;
888	default:
889		print_integer(fp, arg, base);
890		break;
891	}
892}
893
894bool
895sysdecode_mmap_flags(FILE *fp, int flags, int *rem)
896{
897	uintmax_t val;
898	bool printed;
899	int align;
900
901	/*
902	 * MAP_ALIGNED can't be handled directly by print_mask_int().
903	 * MAP_32BIT is also problematic since it isn't defined for
904	 * all platforms.
905	 */
906	printed = false;
907	align = flags & MAP_ALIGNMENT_MASK;
908	val = (unsigned)flags & ~MAP_ALIGNMENT_MASK;
909	print_mask_part(fp, mmapflags, &val, &printed);
910#ifdef MAP_32BIT
911	if (val & MAP_32BIT) {
912		fprintf(fp, "%sMAP_32BIT", printed ? "|" : "");
913		printed = true;
914		val &= ~MAP_32BIT;
915	}
916#endif
917	if (align != 0) {
918		if (printed)
919			fputc('|', fp);
920		if (align == MAP_ALIGNED_SUPER)
921			fputs("MAP_ALIGNED_SUPER", fp);
922		else
923			fprintf(fp, "MAP_ALIGNED(%d)",
924			    align >> MAP_ALIGNMENT_SHIFT);
925		printed = true;
926	}
927	if (rem != NULL)
928		*rem = val;
929	return (printed);
930}
931
932const char *
933sysdecode_rtprio_function(int function)
934{
935
936	return (lookup_value(rtpriofuncs, function));
937}
938
939bool
940sysdecode_msg_flags(FILE *fp, int flags, int *rem)
941{
942
943	return (print_mask_0(fp, msgflags, flags, rem));
944}
945
946const char *
947sysdecode_sigcode(int sig, int si_code)
948{
949	const char *str;
950
951	str = lookup_value(sigcode, si_code);
952	if (str != NULL)
953		return (str);
954
955	switch (sig) {
956	case SIGILL:
957		return (sysdecode_sigill_code(si_code));
958	case SIGBUS:
959		return (sysdecode_sigbus_code(si_code));
960	case SIGSEGV:
961		return (sysdecode_sigsegv_code(si_code));
962	case SIGFPE:
963		return (sysdecode_sigfpe_code(si_code));
964	case SIGTRAP:
965		return (sysdecode_sigtrap_code(si_code));
966	case SIGCHLD:
967		return (sysdecode_sigchld_code(si_code));
968	default:
969		return (NULL);
970	}
971}
972
973bool
974sysdecode_umtx_cvwait_flags(FILE *fp, u_long flags, u_long *rem)
975{
976
977	return (print_mask_0ul(fp, umtxcvwaitflags, flags, rem));
978}
979
980bool
981sysdecode_umtx_rwlock_flags(FILE *fp, u_long flags, u_long *rem)
982{
983
984	return (print_mask_0ul(fp, umtxrwlockflags, flags, rem));
985}
986
987void
988sysdecode_cap_rights(FILE *fp, cap_rights_t *rightsp)
989{
990	struct name_table *t;
991	int i;
992	bool comma;
993
994	for (i = 0; i < CAPARSIZE(rightsp); i++) {
995		if (CAPIDXBIT(rightsp->cr_rights[i]) != 1 << i) {
996			fprintf(fp, "invalid cap_rights_t");
997			return;
998		}
999	}
1000	comma = false;
1001	for (t = caprights; t->str != NULL; t++) {
1002		if (cap_rights_is_set(rightsp, t->val)) {
1003			fprintf(fp, "%s%s", comma ? "," : "", t->str);
1004			comma = true;
1005		}
1006	}
1007}
1008