flags.c revision 838d4edd0a38d39d1c1edd8a2b03c5deaf6c8535
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$");
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_getrusage_who(int who)
491{
492
493	return (lookup_value(rusage, who));
494}
495
496const char *
497sysdecode_kldsym_cmd(int cmd)
498{
499
500	return (lookup_value(kldsymcmd, cmd));
501}
502
503const char *
504sysdecode_kldunload_flags(int flags)
505{
506
507	return (lookup_value(kldunloadfflags, flags));
508}
509
510const char *
511sysdecode_lio_listio_mode(int mode)
512{
513
514	return (lookup_value(lio_listiomodes, mode));
515}
516
517const char *
518sysdecode_madvice(int advice)
519{
520
521	return (lookup_value(madvisebehav, advice));
522}
523
524const char *
525sysdecode_minherit_inherit(int inherit)
526{
527
528	return (lookup_value(minheritflags, inherit));
529}
530
531bool
532sysdecode_mlockall_flags(FILE *fp, int flags, int *rem)
533{
534
535	return (print_mask_int(fp, mlockallflags, flags, rem));
536}
537
538bool
539sysdecode_mmap_prot(FILE *fp, int prot, int *rem)
540{
541
542	return (print_mask_int(fp, mmapprot, prot, rem));
543}
544
545bool
546sysdecode_fileflags(FILE *fp, fflags_t flags, fflags_t *rem)
547{
548
549	return (print_mask_0(fp, fileflags, flags, rem));
550}
551
552bool
553sysdecode_filemode(FILE *fp, int mode, int *rem)
554{
555
556	return (print_mask_0(fp, filemode, mode, rem));
557}
558
559bool
560sysdecode_mount_flags(FILE *fp, int flags, int *rem)
561{
562
563	return (print_mask_int(fp, mountflags, flags, rem));
564}
565
566bool
567sysdecode_msync_flags(FILE *fp, int flags, int *rem)
568{
569
570	return (print_mask_int(fp, msyncflags, flags, rem));
571}
572
573const char *
574sysdecode_nfssvc_flags(int flags)
575{
576
577	return (lookup_value(nfssvcflags, flags));
578}
579
580static struct name_table pipe2flags[] = {
581	X(O_CLOEXEC) X(O_NONBLOCK) XEND
582};
583
584bool
585sysdecode_pipe2_flags(FILE *fp, int flags, int *rem)
586{
587
588	return (print_mask_0(fp, pipe2flags, flags, rem));
589}
590
591const char *
592sysdecode_prio_which(int which)
593{
594
595	return (lookup_value(prio, which));
596}
597
598const char *
599sysdecode_procctl_cmd(int cmd)
600{
601
602	return (lookup_value(procctlcmd, cmd));
603}
604
605const char *
606sysdecode_ptrace_request(int request)
607{
608
609	return (lookup_value(ptraceop, request));
610}
611
612static struct name_table quotatypes[] = {
613	X(GRPQUOTA) X(USRQUOTA) XEND
614};
615
616bool
617sysdecode_quotactl_cmd(FILE *fp, int cmd)
618{
619	const char *primary, *type;
620
621	primary = lookup_value(quotactlcmds, cmd >> SUBCMDSHIFT);
622	if (primary == NULL)
623		return (false);
624	fprintf(fp, "QCMD(%s,", primary);
625	type = lookup_value(quotatypes, cmd & SUBCMDMASK);
626	if (type != NULL)
627		fprintf(fp, "%s", type);
628	else
629		fprintf(fp, "%#x", cmd & SUBCMDMASK);
630	fprintf(fp, ")");
631	return (true);
632}
633
634bool
635sysdecode_reboot_howto(FILE *fp, int howto, int *rem)
636{
637
638	return (print_mask_int(fp, rebootopt, howto, rem));
639}
640
641bool
642sysdecode_rfork_flags(FILE *fp, int flags, int *rem)
643{
644
645	return (print_mask_int(fp, rforkflags, flags, rem));
646}
647
648const char *
649sysdecode_rlimit(int resource)
650{
651
652	return (lookup_value(rlimit, resource));
653}
654
655const char *
656sysdecode_scheduler_policy(int policy)
657{
658
659	return (lookup_value(schedpolicy, policy));
660}
661
662bool
663sysdecode_sendfile_flags(FILE *fp, int flags, int *rem)
664{
665
666	return (print_mask_int(fp, sendfileflags, flags, rem));
667}
668
669bool
670sysdecode_shmat_flags(FILE *fp, int flags, int *rem)
671{
672
673	return (print_mask_int(fp, shmatflags, flags, rem));
674}
675
676const char *
677sysdecode_shutdown_how(int how)
678{
679
680	return (lookup_value(shutdownhow, how));
681}
682
683const char *
684sysdecode_sigbus_code(int si_code)
685{
686
687	return (lookup_value(sigbuscode, si_code));
688}
689
690const char *
691sysdecode_sigchld_code(int si_code)
692{
693
694	return (lookup_value(sigchldcode, si_code));
695}
696
697const char *
698sysdecode_sigfpe_code(int si_code)
699{
700
701	return (lookup_value(sigfpecode, si_code));
702}
703
704const char *
705sysdecode_sigill_code(int si_code)
706{
707
708	return (lookup_value(sigillcode, si_code));
709}
710
711const char *
712sysdecode_sigsegv_code(int si_code)
713{
714
715	return (lookup_value(sigsegvcode, si_code));
716}
717
718const char *
719sysdecode_sigtrap_code(int si_code)
720{
721
722	return (lookup_value(sigtrapcode, si_code));
723}
724
725const char *
726sysdecode_sigprocmask_how(int how)
727{
728
729	return (lookup_value(sigprocmaskhow, how));
730}
731
732const char *
733sysdecode_socketdomain(int domain)
734{
735
736	return (lookup_value(sockdomain, domain));
737}
738
739const char *
740sysdecode_socket_protocol(int domain, int protocol)
741{
742
743	switch (domain) {
744	case PF_INET:
745	case PF_INET6:
746		return (lookup_value(sockipproto, protocol));
747	default:
748		return (NULL);
749	}
750}
751
752const char *
753sysdecode_sockaddr_family(int sa_family)
754{
755
756	return (lookup_value(sockfamily, sa_family));
757}
758
759const char *
760sysdecode_ipproto(int protocol)
761{
762
763	return (lookup_value(sockipproto, protocol));
764}
765
766const char *
767sysdecode_sockopt_name(int level, int optname)
768{
769
770	if (level == SOL_SOCKET)
771		return (lookup_value(sockopt, optname));
772	if (level == IPPROTO_IP)
773		/* XXX: UNIX domain socket options use a level of 0 also. */
774		return (lookup_value(sockoptip, optname));
775	if (level == IPPROTO_IPV6)
776		return (lookup_value(sockoptipv6, optname));
777	if (level == IPPROTO_SCTP)
778		return (lookup_value(sockoptsctp, optname));
779	if (level == IPPROTO_TCP)
780		return (lookup_value(sockopttcp, optname));
781	if (level == IPPROTO_UDP)
782		return (lookup_value(sockoptudp, optname));
783	if (level == IPPROTO_UDPLITE)
784		return (lookup_value(sockoptudplite, optname));
785	return (NULL);
786}
787
788bool
789sysdecode_thr_create_flags(FILE *fp, int flags, int *rem)
790{
791
792	return (print_mask_int(fp, thrcreateflags, flags, rem));
793}
794
795const char *
796sysdecode_umtx_op(int op)
797{
798
799	return (lookup_value(umtxop, op));
800}
801
802const char *
803sysdecode_vmresult(int result)
804{
805
806	return (lookup_value(vmresult, result));
807}
808
809bool
810sysdecode_wait4_options(FILE *fp, int options, int *rem)
811{
812	bool printed;
813	int opt6;
814
815	/* A flags value of 0 is normal. */
816	if (options == 0) {
817		fputs("0", fp);
818		if (rem != NULL)
819			*rem = 0;
820		return (true);
821	}
822
823	/*
824	 * These flags are implicit and aren't valid flags for wait4()
825	 * directly (though they don't fail with EINVAL).
826	 */
827	opt6 = options & (WEXITED | WTRAPPED);
828	options &= ~opt6;
829	printed = print_mask_int(fp, wait6opt, options, rem);
830	if (rem != NULL)
831		*rem |= opt6;
832	return (printed);
833}
834
835bool
836sysdecode_wait6_options(FILE *fp, int options, int *rem)
837{
838
839	return (print_mask_int(fp, wait6opt, options, rem));
840}
841
842const char *
843sysdecode_whence(int whence)
844{
845
846	return (lookup_value(seekwhence, whence));
847}
848
849const char *
850sysdecode_fcntl_cmd(int cmd)
851{
852
853	return (lookup_value(fcntlcmd, cmd));
854}
855
856static struct name_table fcntl_fd_arg[] = {
857	X(FD_CLOEXEC) X(0) XEND
858};
859
860bool
861sysdecode_fcntl_arg_p(int cmd)
862{
863
864	switch (cmd) {
865	case F_GETFD:
866	case F_GETFL:
867	case F_GETOWN:
868		return (false);
869	default:
870		return (true);
871	}
872}
873
874void
875sysdecode_fcntl_arg(FILE *fp, int cmd, uintptr_t arg, int base)
876{
877	int rem;
878
879	switch (cmd) {
880	case F_SETFD:
881		if (!print_value(fp, fcntl_fd_arg, arg))
882		    print_integer(fp, arg, base);
883		break;
884	case F_SETFL:
885		if (!sysdecode_fcntl_fileflags(fp, arg, &rem))
886			fprintf(fp, "%#x", rem);
887		else if (rem != 0)
888			fprintf(fp, "|%#x", rem);
889		break;
890	case F_GETLK:
891	case F_SETLK:
892	case F_SETLKW:
893		fprintf(fp, "%p", (void *)arg);
894		break;
895	default:
896		print_integer(fp, arg, base);
897		break;
898	}
899}
900
901bool
902sysdecode_mmap_flags(FILE *fp, int flags, int *rem)
903{
904	uintmax_t val;
905	bool printed;
906	int align;
907
908	/*
909	 * MAP_ALIGNED can't be handled directly by print_mask_int().
910	 * MAP_32BIT is also problematic since it isn't defined for
911	 * all platforms.
912	 */
913	printed = false;
914	align = flags & MAP_ALIGNMENT_MASK;
915	val = (unsigned)flags & ~MAP_ALIGNMENT_MASK;
916	print_mask_part(fp, mmapflags, &val, &printed);
917#ifdef MAP_32BIT
918	if (val & MAP_32BIT) {
919		fprintf(fp, "%sMAP_32BIT", printed ? "|" : "");
920		printed = true;
921		val &= ~MAP_32BIT;
922	}
923#endif
924	if (align != 0) {
925		if (printed)
926			fputc('|', fp);
927		if (align == MAP_ALIGNED_SUPER)
928			fputs("MAP_ALIGNED_SUPER", fp);
929		else
930			fprintf(fp, "MAP_ALIGNED(%d)",
931			    align >> MAP_ALIGNMENT_SHIFT);
932		printed = true;
933	}
934	if (rem != NULL)
935		*rem = val;
936	return (printed);
937}
938
939const char *
940sysdecode_rtprio_function(int function)
941{
942
943	return (lookup_value(rtpriofuncs, function));
944}
945
946bool
947sysdecode_msg_flags(FILE *fp, int flags, int *rem)
948{
949
950	return (print_mask_0(fp, msgflags, flags, rem));
951}
952
953const char *
954sysdecode_sigcode(int sig, int si_code)
955{
956	const char *str;
957
958	str = lookup_value(sigcode, si_code);
959	if (str != NULL)
960		return (str);
961
962	switch (sig) {
963	case SIGILL:
964		return (sysdecode_sigill_code(si_code));
965	case SIGBUS:
966		return (sysdecode_sigbus_code(si_code));
967	case SIGSEGV:
968		return (sysdecode_sigsegv_code(si_code));
969	case SIGFPE:
970		return (sysdecode_sigfpe_code(si_code));
971	case SIGTRAP:
972		return (sysdecode_sigtrap_code(si_code));
973	case SIGCHLD:
974		return (sysdecode_sigchld_code(si_code));
975	default:
976		return (NULL);
977	}
978}
979
980bool
981sysdecode_umtx_cvwait_flags(FILE *fp, u_long flags, u_long *rem)
982{
983
984	return (print_mask_0ul(fp, umtxcvwaitflags, flags, rem));
985}
986
987bool
988sysdecode_umtx_rwlock_flags(FILE *fp, u_long flags, u_long *rem)
989{
990
991	return (print_mask_0ul(fp, umtxrwlockflags, flags, rem));
992}
993
994void
995sysdecode_cap_rights(FILE *fp, cap_rights_t *rightsp)
996{
997	struct name_table *t;
998	bool comma;
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